feat(FIR-37168): testConnection doesn't reset autostop timer

src/connection/base.ts

@@ -54,6 +54,8 @@ export abstract class Connection {
 
   abstract resolveEngineEndpoint(): Promise<string>;
 
+  abstract testConnection(): Promise<void>;
+
   protected getRequestUrl(executeQueryOptions: ExecuteQueryOptions): string {
     const params = this.getBaseParameters(executeQueryOptions);
 
@@ -81,7 +83,15 @@ export abstract class Connection {
     const strSettings = Object.entries(settings ?? {}).reduce<
       Record<string, string>
     >((acc, [key, value]) => {
-      if (value !== undefined) {
+      if (key === "internal") {
+        // Unwrap internal settings from array
+        const internalSettings = value as Record<string, string | number>[];
+        internalSettings.forEach(setting => {
+          Object.entries(setting).forEach(([internalKey, internalValue]) => {
+            acc[internalKey] = internalValue.toString();
+          });
+        });
+      } else if (value !== undefined) {
         acc[key] = value.toString();
       }
       return acc;

src/connection/connection_v1.ts

@@ -59,4 +59,8 @@ export class ConnectionV1 extends BaseConnection {
     }
     return this.accountInfo;
   }
+
+  async testConnection() {
+    await this.execute("select 1");
+  }
 }

src/connection/connection_v2.ts

@@ -69,4 +69,9 @@ export class ConnectionV2 extends BaseConnection {
 
     return this.engineEndpoint;
   }
+
+  async testConnection() {
+    const settings = { internal: [{ auto_start_stop_control: "ignore" }] };
+    await this.execute("select 1", { settings });
+  }
 }

src/core/index.ts

@@ -31,6 +31,6 @@ export class FireboltCore {
     const connection = makeConnection(this.context, connectionOptions);
     await auth.authenticate();
     await connection.resolveEngineEndpoint();
-    await connection.execute("select 1");
+    await connection.testConnection();
   }
 }

src/types.ts

@@ -31,9 +31,10 @@ export enum OutputFormat {
 
 export type QuerySettings = Record<
   string,
-  string | number | boolean | undefined
+  string | number | boolean | undefined | Record<string, string | number>[]
 > & {
   output_format?: OutputFormat;
+  internal?: Record<string, string | number>[];
 };
 
 export type RowParser = (row: string, isLastRow: boolean) => any;

test/unit/connection.test.ts

@@ -493,6 +493,36 @@ INFO: SYNTAX_ERROR - Unexpected character at {"failingLine":42,"startOffset":120
     expect(searchParamsUsed.get("param")).toEqual("value");
   });
 
+  it("handles settings in execute", async () => {
+    server.use(
+      rest.post(`https://some_engine.com`, async (req, res, ctx) => {
+        const body = await req.text();
+        const urlParams = Object.fromEntries(req.url.searchParams.entries());
+        expect(urlParams).toHaveProperty("param");
+        if (body.startsWith("SELECT 1")) {
+          return res(ctx.json(emptyResponse));
+        }
+      })
+    );
+
+    const connectionParams: ConnectionOptions = {
+      auth: {
+        client_id: "dummy",
+        client_secret: "dummy"
+      },
+      database: "dummy",
+      engineName: "dummy",
+      account: "my_account"
+    };
+    const firebolt = Firebolt({
+      apiEndpoint
+    });
+
+    const connection = await firebolt.connect(connectionParams);
+    await connection.execute("SELECT 1", { settings: { param: "value" } });
+  });
+
+
   it("handles invalid set statements correctly", async () => {
     let searchParamsUsed = new URLSearchParams();
     let searchParamsUsed2 = new URLSearchParams();

test/unit/v1/connection.test.ts

@@ -3,7 +3,6 @@ import { rest } from "msw";
 import { ConnectionOptions, Firebolt } from "../../../src";
 import { ConnectionV1 } from "../../../src/connection/connection_v1";
 
-
 const apiEndpoint = "fake.api.com";
 const accountName = "my_account";
 
@@ -136,6 +135,33 @@ describe("Connection v1", () => {
     ).resolveAccountInfo();
     expect(account_info.id).toBe("some_account");
   });
+  it("testConnection works", async () => {
+    // override select 1 response and check within it that query parameter is not set
+    server.use(
+      rest.post(`https://some_engine.com/`, (req, res, ctx) => {
+        const urlParams = Object.fromEntries(req.url.searchParams.entries());
+        expect(urlParams).not.toContain("auto_start_stop_control");
+        return res(ctx.json(selectOneResponse));
+      })
+    );
+
+    const firebolt = Firebolt({ apiEndpoint });
+
+    const connectionParams: ConnectionOptions = {
+      auth: {
+        username: "user",
+        password: "pass"
+      },
+      database: "dummy",
+      engineName: "dummy",
+      account: accountName
+    };
+
+    const connection = await firebolt.connect(connectionParams);
+    await connection.testConnection();
+    // also test the method from core
+    await firebolt.testConnection(connectionParams);
+  });
   it("Can run set statements", async () => {
     const param = "my_var";
     const value = "1";

test/unit/v2/connection.test.ts

@@ -162,6 +162,52 @@ describe("Connection V2", () => {
 
     expect(engineUrlCalls).toBe(1);
   });
+  it("testConnection works", async () => {
+    const firebolt = Firebolt({
+      apiEndpoint
+    });
+
+    server.use(
+      rest.post(`https://id.fake.firebolt.io/oauth/token`, (req, res, ctx) => {
+        return res(
+          ctx.json({
+            access_token: "fake_access_token"
+          })
+        );
+      }),
+      rest.get(
+        `https://api.fake.firebolt.io/web/v3/account/my_account/engineUrl`,
+        (req, res, ctx) => {
+          return res(
+            ctx.json({
+              engineUrl: "https://some_system_engine.com"
+            })
+          );
+        }
+      ),
+      rest.post(
+        `https://some_system_engine.com/${QUERY_URL}`,
+        (req, res, ctx) => {
+          const urlParams = Object.fromEntries(req.url.searchParams.entries());
+          expect(urlParams).toHaveProperty("auto_start_stop_control");
+          return res(ctx.json(engineUrlResponse));
+        }
+      )
+    );
+
+    const connectionParams: ConnectionOptions = {
+      auth: {
+        client_id: "dummy",
+        client_secret: "dummy"
+      },
+      account: "my_account"
+    };
+
+    const connection = await firebolt.connect(connectionParams);
+    await connection.testConnection();
+    // also test the method from core
+    await firebolt.testConnection(connectionParams);
+  });
   it("respects useCache option", async () => {
     const firebolt = Firebolt({
       apiEndpoint