fix

Author: Evan Roman

src/cosmosDB.test.ts

@@ -6,13 +6,21 @@ import { expect } from 'chai';
 import { default as fetch } from 'node-fetch';
 import { getFuncUrl, CosmosDB } from './constants';
 import { waitForOutput } from './global.test';
-import { cosmosDBConnectionString } from './utils/connectionStrings';
 import { getRandomTestData } from './utils/getRandomTestData';
+import { setupCosmosDB } from './utils/cosmosdb/setupCosmosDB';
 
 describe('cosmosDB', () => {
+    let cosmosClient: CosmosClient | undefined;
+    before(async function (this: Mocha.Context) {
+        cosmosClient = await setupCosmosDB();
+    });
+
+    after(async () => {
+        void cosmosClient?.dispose();
+    });
+
     it('trigger, output, input', async () => {
-        const client = new CosmosClient(cosmosDBConnectionString);
-        const container = client.database(CosmosDB.dbName).container(CosmosDB.triggerAndOutputContainerName);
+        const container = cosmosClient!.database(CosmosDB.dbName).container(CosmosDB.triggerAndOutputContainerName);
         const testData = getRandomTestData();
         const createdItem = await container.items.create({ testData, testPartKey: CosmosDB.partitionKey });
 

src/global.test.ts

@@ -6,7 +6,7 @@ import * as fs from 'fs/promises';
 import path from 'path';
 import semver from 'semver';
 import { combinedFolder, defaultTimeout, EnvVarNames, oldConfigSuffix } from './constants';
-import { getModelArg, getOldConfigArg, getTestFileFilter, Model } from './getModelArg';
+import { getModelArg, getOldConfigArg, Model } from './getModelArg';
 import {
     cosmosDBConnectionString,
     eventHubConnectionString,
@@ -17,8 +17,8 @@ import {
 } from './utils/connectionStrings';
 import { delay } from './utils/delay';
 import findProcess = require('find-process');
-import { setupCosmosDB } from './utils/cosmosdb/setupCosmosDB';
-import { runSqlSetupQueries } from './utils/sql/setupSql';
+// import { setupCosmosDB } from './utils/cosmosdb/setupCosmosDB';
+// import { runSqlSetupQueries } from './utils/sql/setupSql';
 
 let perTestFuncOutput = '';
 let fullFuncOutput = '';
@@ -43,11 +43,11 @@ before(async function (this: Mocha.Context): Promise<void> {
 
     await initializeConnectionStrings();
 
-    const { only } = getTestFileFilter();
-    if (only) {
-        await runSqlSetupQueries();
-        await setupCosmosDB();
-    }
+    // const { only } = getTestFileFilter();
+    // if (only) {
+    //     await runSqlSetupQueries();
+    //     await setupCosmosDB();
+    // }
 
     isOldConfig = getOldConfigArg();
     const appPath = isOldConfig

src/sql.test.ts

@@ -8,8 +8,7 @@ import { Sql, getFuncUrl } from './constants';
 import { isOldConfig, waitForOutput } from './global.test';
 import { getRandomTestData } from './utils/getRandomTestData';
 import { ConnectionPool } from 'mssql';
-import { createPoolConnnection } from './utils/sql/setupSql';
-import { sqlTestConnectionString } from './utils/connectionStrings';
+import { runSqlSetupQueries } from './utils/sql/setupSql';
 
 describe('sql', () => {
     let poolConnection: ConnectionPool | undefined;
@@ -18,11 +17,11 @@ describe('sql', () => {
             this.skip();
         }
 
-        poolConnection = await createPoolConnnection(sqlTestConnectionString);
+        poolConnection = await runSqlSetupQueries();
     });
 
     after(async () => {
-        await poolConnection?.close();
+        void poolConnection?.close();
     });
 
     type SqlItem = { id: string; testData: string };

src/utils/cosmosdb/setupCosmosDB.ts

@@ -9,11 +9,8 @@ import { CosmosClient, PartitionKeyKind } from '@azure/cosmos';
 import { cosmosDBConnectionString } from '../connectionStrings';
 import { CosmosDB } from '../../constants';
 
-export async function setupCosmosDB() {
+export async function setupCosmosDB(): Promise<CosmosClient> {
     const partitionKeyPath = `/${CosmosDB.partitionKey}`;
-    if (!cosmosDBConnectionString) {
-      throw new Error('CosmosDB connection string is not set');
-    }
     const client = new CosmosClient(cosmosDBConnectionString);
     await client.databases.createIfNotExists({ id: CosmosDB.triggerDatabaseName });
     await client.database(CosmosDB.triggerDatabaseName).containers.createIfNotExists({
@@ -24,4 +21,5 @@ export async function setupCosmosDB() {
       id: CosmosDB.triggerAndOutputContainerName,
       partitionKey: { paths: [partitionKeyPath], kind: PartitionKeyKind.Hash }
     });
+    return client;
 }

src/utils/sql/setupSql.ts

@@ -6,7 +6,7 @@ import retry from 'p-retry';
 import { sqlConnectionString, sqlTestConnectionString } from '../connectionStrings';
 import { Sql } from '../../constants';
 
-export async function runSqlSetupQueries() {
+export async function runSqlSetupQueries(): Promise<sql.ConnectionPool> {
     // STEP 1: Create DB if not exists
     let pool = await createPoolConnnection(sqlConnectionString);
     await pool.request().query(`
@@ -45,25 +45,23 @@ export async function runSqlSetupQueries() {
 
     // STEP 3: Create tables and enable tracking
     pool = await createPoolConnnection(sqlTestConnectionString);
-    try {
-        for (const table of [Sql.sqlTriggerTable, Sql.sqlNonTriggerTable]) {
-            await pool.request().query(`
-                IF OBJECT_ID('dbo.${table}', 'U') IS NULL
-                BEGIN
-                    CREATE TABLE dbo.${table} (
-                        id UNIQUEIDENTIFIER PRIMARY KEY,
-                        testData NVARCHAR(200) NOT NULL
-                    );
-                    ALTER TABLE dbo.${table} ENABLE CHANGE_TRACKING;
-                END
-            `);
-        }
-    } finally {
-        await pool.close();
+    for (const table of [Sql.sqlTriggerTable, Sql.sqlNonTriggerTable]) {
+        await pool.request().query(`
+            IF OBJECT_ID('dbo.${table}', 'U') IS NULL
+            BEGIN
+                CREATE TABLE dbo.${table} (
+                    id UNIQUEIDENTIFIER PRIMARY KEY,
+                    testData NVARCHAR(200) NOT NULL
+                );
+                ALTER TABLE dbo.${table} ENABLE CHANGE_TRACKING;
+            END
+        `);
     }
+
+    return pool;
 }
 
-export async function createPoolConnnection(connectionString: string): Promise<sql.ConnectionPool> {
+async function createPoolConnnection(connectionString: string): Promise<sql.ConnectionPool> {
     const retries = 5;
     return retry(
         async (currentAttempt: number) => {