@oino-ts/db 0.6.1 → 0.7.1

package/src/OINODbApi.test.ts

@@ -6,7 +6,7 @@
 
 import { expect, test } from "bun:test";
 
-import { OINODbApi, OINODbApiParams, OINOContentType, OINODataRow, OINODbDataField, OINOStringDataField, OINODb, OINODbFactory, OINODbParams, OINODbMemoryDataSet, OINODbModelSet, OINOBenchmark, OINOConsoleLog, OINODbSqlFilter, OINODbConfig, OINODbSqlOrder, OINOLogLevel, OINOLog, OINODbSqlLimit, OINODbApiResult, OINODbSqlComparison, OINONumberDataField, OINODatetimeDataField, OINODbApiRequestParams, OINODbHtmlTemplate } from "./index.js";
+import { OINODbApi, OINODbApiParams, OINOContentType, OINODataRow, OINODbDataField, OINOStringDataField, OINODb, OINODbFactory, OINODbParams, OINODbMemoryDataSet, OINODbModelSet, OINOBenchmark, OINOConsoleLog, OINODbSqlFilter, OINODbConfig, OINODbSqlOrder, OINOLogLevel, OINOLog, OINODbSqlLimit, OINODbApiResult, OINODbSqlComparison, OINONumberDataField, OINODatetimeDataField, OINODbApiRequestParams, OINODbHtmlTemplate, OINODbParser } from "./index.js";
 
 import { OINODbBunSqlite } from "@oino-ts/db-bunsqlite"
 import { OINODbPostgresql } from "@oino-ts/db-postgresql"
@@ -28,14 +28,14 @@ type OINOTestParams = {
     putRow: OINODataRow
 }
 
-const dbs:OINODbParams[] = [
+const DATABASES:OINODbParams[] = [
     { type: "OINODbBunSqlite", url:"file://./localDb/northwind.sqlite", database: "Northwind" }, 
     { type: "OINODbPostgresql", url: "localhost", database: "Northwind", port:5432, user: "node", password: OINODB_POSTGRESQL_TOKEN },
     { type: "OINODbMariadb", url: "127.0.0.1", database: "Northwind", port:6543, user: "node", password: OINODB_MARIADB_TOKEN }, 
     { type: "OINODbMsSql", url: OINOCLOUD_MSSQL_TEST_SRV, database: "Northwind", port:1433, user: OINOCLOUD_MSSQL_TEST_USER, password: OINOCLOUD_MSSQL_TEST_PWD } 
 ]
 
-const api_tests:OINOTestParams[] = [
+const API_TESTS:OINOTestParams[] = [
     {
         name: "API 1",
         apiParams: { apiName: "Orders", tableName: "Orders" },
@@ -75,7 +75,7 @@ const api_tests:OINOTestParams[] = [
     
 ]
 
-const owasp_tests:OINOTestParams[] = [
+const OWASP_TESTS:OINOTestParams[] = [
     {
         name: "OWASP 1",
         apiParams: { apiName: "Products", tableName: "Products", failOnOversizedValues: true },
@@ -105,6 +105,25 @@ const owasp_tests:OINOTestParams[] = [
     }
 ]
 
+const API_CROSSCHECKS:string[] = [
+    "[HTTP GET] select *: GET JSON 1",
+    "[HTTP GET] select * with template: GET HTML 1",
+    "[HTTP POST] insert: GET JSON 1",
+    "[HTTP POST] insert: GET CSV 1",
+    "[HTTP PUT] update JSON: GET JSON 1",
+    "[HTTP PUT] update CSV: GET CSV 1",
+    "[HTTP PUT] update FORMDATA: GET FORMDATA 1",
+    "[HTTP PUT] update URLENCODE: GET URLENCODE 1",
+    "[BATCH UPDATE] reversed values: GET reversed data 1",
+    "[BATCH UPDATE] reversed values: GET restored data 1"
+]
+
+const OWASP_CROSSCHECKS:string[] = [
+    "[OWASP POST] POST: POST JSON 1",
+    "[OWASP PUT] PUT: OWASP PUT RESULT 1"
+]
+
+
 Math.random()
 
 OINOLog.setLogger(new OINOConsoleLog(OINOLogLevel.error))
@@ -153,7 +172,7 @@ export async function OINOTestApi(dbParams:OINODbParams, testParams: OINOTestPar
         const wrong_pwd_params:OINODbParams = Object.assign({}, dbParams)
         wrong_pwd_params.password = "WRONG_PASSWORD"
         const wrong_pwd_db:OINODb = await OINODbFactory.createDb( wrong_pwd_params, false, false )
-        test(target_name + target_db + target_table + target_group + " connection error", async () => {
+        await test(target_name + target_db + target_table + target_group + " connection error", async () => {
             expect(wrong_pwd_db).toBeDefined()
 
             const connect_res = await wrong_pwd_db.connect()
@@ -164,13 +183,14 @@ export async function OINOTestApi(dbParams:OINODbParams, testParams: OINOTestPar
 
     // const db:OINODb = await OINODbFactory.createDb( dbParams )
     const db:OINODb = await OINODbFactory.createDb( dbParams )
-    test(target_name + target_db + target_table + target_group + " connection success", async () => {
+    await test(target_name + target_db + target_table + target_group + " connection success", async () => {
         expect(db).toBeDefined()
         expect(db.isConnected).toBe(true)
         expect(db.isValidated).toBe(true)
     })
 
     const api:OINODbApi = await OINODbFactory.createApi(db, testParams.apiParams)
+    api.setDebugOnError(true) // we want debug output (e.g. used sql and exceptions) so that we know that failing tests fail for the correct reason
 
     const post_dataset:OINODbMemoryDataSet = new OINODbMemoryDataSet([testParams.postRow])
     const post_modelset:OINODbModelSet = new OINODbModelSet(api.datamodel, post_dataset)
@@ -189,32 +209,32 @@ export async function OINOTestApi(dbParams:OINODbParams, testParams: OINOTestPar
     request_params_with_filters.sqlParams = testParams.requestParams.sqlParams
     // OINOLog.debug("OINOTestApi", {request_params:request_params, request_params_with_filters:request_params_with_filters})
     
-    // test("dummy", () => {
+    // await test("dummy", () => {
     //     expect({foo:"h\\i"}).toMatchSnapshot()
     // })
 
     target_group = "[SCHEMA]"
-    test(target_name + target_db + target_table + target_group + " public properties", async () => {
+    await test(target_name + target_db + target_table + target_group + " public properties", async () => {
         expect(api.datamodel.printFieldPublicPropertiesJson()).toMatchSnapshot("SCHEMA")
     })
     
     target_group = "[HTTP GET]"
-    test(target_name + target_db + target_table + target_group + " select *", async () => {
+    await test(target_name + target_db + target_table + target_group + " select *", async () => {
         expect(encodeData(await (await api.doRequest("GET", "", "", empty_params)).data?.writeString())).toMatchSnapshot("GET JSON")
     })
     
-    test(target_name + target_db + target_table + target_group + " select *", async () => {
+    await test(target_name + target_db + target_table + target_group + " select *", async () => {
         expect(encodeData(await (await api.doRequest("GET", "", "", empty_params)).data?.writeString(OINOContentType.csv))).toMatchSnapshot("GET CSV")
     })
 
-    test(target_name + target_db + target_table + target_group + " select * with template", async () => {
+    await test(target_name + target_db + target_table + target_group + " select * with template", async () => {
         const template = createApiTemplate(api)
         const api_result:OINODbApiResult = await api.doRequest("GET", "", "", empty_params)
         const html = (await template.renderFromDbData(api_result.data!)).body
         expect(encodeData(html)).toMatchSnapshot("GET HTML")
     })
 
-    test(target_name + target_db + target_table + target_group + " select * with filter", async () => {
+    await test(target_name + target_db + target_table + target_group + " select * with filter", async () => {
         expect(encodeData(await (await api.doRequest("GET", "", "", request_params_with_filters)).data?.writeString())).toMatchSnapshot("GET JSON FILTER")
     })
     
@@ -225,25 +245,25 @@ export async function OINOTestApi(dbParams:OINODbParams, testParams: OINOTestPar
     target_group = "[HTTP POST]"
     const post_body_json:string = await post_modelset.writeString(OINOContentType.json)
     // OINOLog.info("HTTP POST json", {post_body_json:post_body_json})
-    test(target_name + target_db + target_table + target_group + " insert with id", async () => {
+    await test(target_name + target_db + target_table + target_group + " insert with id", async () => {
         expect(encodeResult((await api.doRequest("POST", new_row_id, post_body_json, empty_params)))).toMatchSnapshot("POST")
     })
-    test(target_name + target_db + target_table + target_group + " insert", async () => {
+    await test(target_name + target_db + target_table + target_group + " insert", async () => {
         expect(encodeResult((await api.doRequest("POST", "", post_body_json, empty_params)))).toMatchSnapshot("POST")
         expect(encodeData(await (await api.doRequest("GET", new_row_id, "", empty_params)).data?.writeString())).toMatchSnapshot("GET JSON")
         expect(encodeData(await (await api.doRequest("GET", new_row_id, "", empty_params)).data?.writeString(OINOContentType.csv))).toMatchSnapshot("GET CSV")
     })
-    test(target_name + target_db + target_table + target_group + " insert no data", async () => {
+    await test(target_name + target_db + target_table + target_group + " insert no data", async () => {
         expect(encodeResult((await api.doRequest("POST", "", "{}", empty_params)))).toMatchSnapshot("POST")
     })
-    test(target_name + target_db + target_table + target_group + " insert duplicate", async () => {
+    await test(target_name + target_db + target_table + target_group + " insert duplicate", async () => {
         expect(encodeResult((await api.doRequest("POST", "", post_body_json, empty_params)))).toMatchSnapshot("POST")
     })
     
     target_group = "[HTTP PUT]"
     const put_body_json = await put_modelset.writeString(OINOContentType.json)
     // OINOLog.info("HTTP PUT JSON", {put_body_json:put_body_json})
-    test(target_name + target_db + target_table + target_group + " update JSON", async () => {
+    await test(target_name + target_db + target_table + target_group + " update JSON", async () => {
         request_params.requestType = OINOContentType.json
         expect(encodeResult((await api.doRequest("PUT", new_row_id, post_body_json, empty_params)))).toMatchSnapshot("PUT JSON reset")
         expect(encodeResult((await api.doRequest("PUT", new_row_id, put_body_json, request_params)))).toMatchSnapshot("PUT JSON")
@@ -253,7 +273,7 @@ export async function OINOTestApi(dbParams:OINODbParams, testParams: OINOTestPar
     put_dataset.first()
     const put_body_csv = await put_modelset.writeString(OINOContentType.csv)
     // OINOLog.info("HTTP PUT csv", {put_body_csv:put_body_csv})
-    test(target_name + target_db + target_table + target_group + " update CSV", async () => {
+    await test(target_name + target_db + target_table + target_group + " update CSV", async () => {
         request_params.requestType = OINOContentType.csv
         expect(encodeResult((await api.doRequest("PUT", new_row_id, post_body_json, empty_params)))).toMatchSnapshot("PUT CSV reset")
         expect(encodeResult((await api.doRequest("PUT", new_row_id, put_body_csv, request_params)))).toMatchSnapshot("PUT CSV")
@@ -265,7 +285,7 @@ export async function OINOTestApi(dbParams:OINODbParams, testParams: OINOTestPar
     const multipart_boundary = put_body_formdata.substring(0, put_body_formdata.indexOf('\r'))
     put_body_formdata = put_body_formdata.replaceAll(multipart_boundary, "---------OINO999999999")
     // OINOLog.info("HTTP PUT FORMDATA", {put_body_formdata:put_body_formdata})
-    test(target_name + target_db + target_table + target_group + " update FORMDATA", async () => {
+    await test(target_name + target_db + target_table + target_group + " update FORMDATA", async () => {
         request_params.requestType = OINOContentType.formdata
         request_params.multipartBoundary = "---------OINO999999999"
         expect(encodeResult(await (await api.doRequest("PUT", new_row_id, post_body_json, empty_params)))).toMatchSnapshot("PUT FORMDATA reset")
@@ -277,7 +297,7 @@ export async function OINOTestApi(dbParams:OINODbParams, testParams: OINOTestPar
     put_dataset.first()
     const put_body_urlencode = await put_modelset.writeString(OINOContentType.urlencode)
     // OINOLog.info("HTTP PUT URLENCODE", {put_body_urlencode:put_body_urlencode})
-    test(target_name + target_db + target_table + target_group + " update URLENCODE", async () => {
+    await test(target_name + target_db + target_table + target_group + " update URLENCODE", async () => {
         request_params.requestType = OINOContentType.urlencode
         request_params.multipartBoundary = undefined // for some reason this needs reset here so previous test value settings does not leak
         expect(encodeResult((await api.doRequest("PUT", new_row_id, post_body_json, empty_params)))).toMatchSnapshot("PUT URLENCODE reset")
@@ -285,7 +305,7 @@ export async function OINOTestApi(dbParams:OINODbParams, testParams: OINOTestPar
         expect(encodeData(await (await api.doRequest("GET", new_row_id, "", empty_params)).data?.writeString(OINOContentType.urlencode))).toMatchSnapshot("GET URLENCODE")
     })
     
-    test(target_name + target_db + target_table + target_group + " update no data", async () => {
+    await test(target_name + target_db + target_table + target_group + " update no data", async () => {
         expect(encodeResult((await api.doRequest("PUT", new_row_id, "{}", empty_params)))).toMatchSnapshot("PUT")
     })
 
@@ -297,14 +317,14 @@ export async function OINOTestApi(dbParams:OINODbParams, testParams: OINOTestPar
         const notnull_fields:OINODbDataField[] = api.datamodel.filterFields((field:OINODbDataField) => { return (field.fieldParams.isPrimaryKey == false) && (field.fieldParams.isNotNull == true) })
         if (notnull_fields.length > 0) {
             const invalid_null_value = "[{\"" + id_field + "\":\"" + new_row_id + "\",\"" + notnull_fields[0].name + "\":null}]"
-            test(target_name + target_db + target_table + target_group + " update with invalid null value", async () => {
+            await test(target_name + target_db + target_table + target_group + " update with invalid null value", async () => {
                 expect(encodeResult((await api.doRequest("PUT", new_row_id, invalid_null_value, empty_params)))).toMatchSnapshot("PUT invalid null")
             })
         }
         const maxsize_fields:OINODbDataField[] = api.datamodel.filterFields((field:OINODbDataField) => { return (field instanceof OINOStringDataField) && (field.fieldParams.isPrimaryKey == false) && (field.maxLength > 0) })
         if (maxsize_fields.length > 0) {
             const oversized_value = "[{\"" + id_field + "\":\"" + new_row_id + "\",\"" + maxsize_fields[0].name + "\":\"" + "".padEnd(maxsize_fields[0].maxLength+1, "z") + "\"}]"
-            test(target_name + target_db + target_table + target_group + " update with oversized data", async () => {
+            await test(target_name + target_db + target_table + target_group + " update with oversized data", async () => {
                 expect(encodeResult((await api.doRequest("PUT", new_row_id, oversized_value, empty_params)))).toMatchSnapshot("PUT oversized value")
             })
         }
@@ -312,7 +332,7 @@ export async function OINOTestApi(dbParams:OINODbParams, testParams: OINOTestPar
         if (numeric_fields.length > 0) {
             const nan_value = "[{\"" + id_field + "\":\"" + new_row_id + "\",\"" + numeric_fields[0].name + "\":\"" + "; FOO" + "\"}]"
             // OINOLog.debug("HTTP PUT NAN-value", {nan_value:nan_value})
-            test(target_name + target_db + target_table + target_group + " update NAN-value", async () => {
+            await test(target_name + target_db + target_table + target_group + " update NAN-value", async () => {
                 expect(encodeResult((await api.doRequest("PUT", new_row_id, nan_value, empty_params)))).toMatchSnapshot("PUT NAN-value")
             })
         }
@@ -320,17 +340,63 @@ export async function OINOTestApi(dbParams:OINODbParams, testParams: OINOTestPar
         if (date_fields.length > 0) {
             const non_date = "[{\"" + id_field + "\":\"" + new_row_id + "\",\"" + date_fields[0].name + "\":\"" + "; FOO" + "\"}]"
             // OINOLog.debug("HTTP PUT invalid date value", {non_date:non_date})
-            test(target_name + target_db + target_table + target_group + " update invalid date value", async () => {
+            await test(target_name + target_db + target_table + target_group + " update invalid date value", async () => {
                 expect(encodeResult((await api.doRequest("PUT", new_row_id, non_date, empty_params)))).toMatchSnapshot("PUT invalid date value")
             })
         }
     }
-    
+
+    target_group = "[BATCH UPDATE]"
+    const string_fields:OINODbDataField[] = api.datamodel.filterFields((field:OINODbDataField) => { return ((field instanceof OINOStringDataField) || (field instanceof OINONumberDataField)) && (field.fieldParams.isPrimaryKey == false) && (field.fieldParams.isForeignKey == false) })
+    if (string_fields.length == 0) {
+        OINOLog.info("BATCH UPDATE table " + testParams.apiParams.tableName + " does not have numeric fields and batch update tests are skipped")
+    } else {
+        const batch_field = string_fields[0]
+        const batch_field_name:string = batch_field.name
+        const batch_field_index:number = api.datamodel.findFieldIndexByName(batch_field_name)
+        const batch_value = testParams.putRow[batch_field_index] 
+        let batch_reversed_value 
+        if (batch_field instanceof OINOStringDataField) {
+            batch_reversed_value = (batch_value as string).split("").reverse().join("")
+        } else {
+            batch_reversed_value = -(batch_value as number)
+        }
+        const batch_rows = [
+            [...testParams.putRow] as OINODataRow,
+            [...testParams.putRow] as OINODataRow,
+            [...testParams.putRow] as OINODataRow
+        ]
+
+        await test(target_name + target_db + target_table + target_group + " reversed values", async () => {
+            batch_rows[0][batch_field_index] = batch_reversed_value
+            batch_rows[1][batch_field_index] = batch_value
+            batch_rows[2][batch_field_index] = batch_reversed_value
+            const batch_update_result = await api.doBatchUpdate("PUT", batch_rows, empty_params)
+            expect(batch_update_result.success).toBe(true)
+            expect(encodeResult(batch_update_result)).toMatchSnapshot("PUT reversed data")
+            
+            const get_reversed_data = await (await api.doRequest("GET", new_row_id, "", empty_params)).data?.writeString(OINOContentType.csv)
+            expect(encodeData(get_reversed_data)).toMatchSnapshot("GET reversed data")
+
+            batch_rows[0][batch_field_index] = batch_value
+            batch_rows[1][batch_field_index] = batch_reversed_value
+            batch_rows[2][batch_field_index] = batch_value
+            const batch_restore_result = await api.doBatchUpdate("PUT", batch_rows, empty_params)
+            expect(batch_restore_result.success).toBe(true)
+            expect(encodeResult(batch_restore_result)).toMatchSnapshot("PUT restored data")
+            
+            const get_restored_data = await (await api.doRequest("GET", new_row_id, "", empty_params)).data?.writeString(OINOContentType.csv)
+            expect(encodeData(get_restored_data)).toMatchSnapshot("GET restored data")
+        })
+    }
+
     target_group = "[HTTP DELETE]"
-    test(target_name + target_db + target_table + target_group + " remove", async () => {
+    await test(target_name + target_db + target_table + target_group + " remove", async () => {
         expect(encodeResult((await api.doRequest("DELETE", new_row_id, "", empty_params)))).toMatchSnapshot("DELETE")
         expect(encodeData(await (await api.doRequest("GET", new_row_id, "", empty_params)).data?.writeString())).toMatchSnapshot("GET JSON")
     })
+   
+
 }
 
 export async function OINOTestOwasp(dbParams:OINODbParams, testParams: OINOTestParams) {
@@ -362,7 +428,7 @@ export async function OINOTestOwasp(dbParams:OINODbParams, testParams: OINOTestP
     let target_table:string = "[" + testParams.apiParams.tableName + "]"
 
     let target_group = "[OWASP GET]"
-    test(target_name + target_db + target_table + target_group + " GET with filter", async () => {
+    await test(target_name + target_db + target_table + target_group + " GET with filter", async () => {
         const get_res:OINODbApiResult = await api.doRequest("GET", "", "", request_params_with_filters)
         if (get_res.success) {
             expect(encodeData(await get_res.data?.writeString())).toMatchSnapshot("OWASP GET DATA")
@@ -371,7 +437,7 @@ export async function OINOTestOwasp(dbParams:OINODbParams, testParams: OINOTestP
         }
     })
     target_group = "[OWASP POST]"
-    test(target_name + target_db + target_table + target_group + " POST", async () => {
+    await test(target_name + target_db + target_table + target_group + " POST", async () => {
         const post_body_json:string = await post_modelset.writeString(OINOContentType.json)
         const post_res:OINODbApiResult = await api.doRequest("POST", "", post_body_json, request_params)
         expect(encodeResult(post_res)).toMatchSnapshot("OWASP POST RESULT")
@@ -379,7 +445,7 @@ export async function OINOTestOwasp(dbParams:OINODbParams, testParams: OINOTestP
     })
 
     target_group = "[OWASP PUT]"
-    test(target_name + target_db + target_table + target_group + " PUT", async () => {
+    await test(target_name + target_db + target_table + target_group + " PUT", async () => {
         const put_body_json:string = await put_modelset.writeString(OINOContentType.json)
         const post_res:OINODbApiResult = await api.doRequest("PUT", new_row_id, put_body_json, request_params)
         expect(encodeResult(post_res)).toMatchSnapshot("OWASP PUT RESULT")
@@ -387,21 +453,21 @@ export async function OINOTestOwasp(dbParams:OINODbParams, testParams: OINOTestP
     })
     
     target_group = "[OWASP DELETE]"
-    test(target_name + target_db + target_table + target_group + " DELETE", async () => {
+    await test(target_name + target_db + target_table + target_group + " DELETE", async () => {
         expect(encodeResult((await api.doRequest("DELETE", new_row_id, "", empty_params)))).toMatchSnapshot("DELETE")
         expect(encodeData(await (await api.doRequest("GET", new_row_id, "", empty_params)).data?.writeString())).toMatchSnapshot("DELETE JSON")
     })
 }
 
 
-for (let db of dbs) {
-    for (let api_test of api_tests) {
+for (let db of DATABASES) {
+    for (let api_test of API_TESTS) {
         await OINOTestApi(db, api_test)
     }
 }
 
-for (let db of dbs) {
-    for (let owasp_test of owasp_tests) {
+for (let db of DATABASES) {
+    for (let owasp_test of OWASP_TESTS) {
         await OINOTestOwasp(db, owasp_test)
     }
 }
@@ -411,36 +477,20 @@ const snapshot_file = Bun.file("./node_modules/@oino-ts/db/src/__snapshots__/OIN
 await Bun.write("./node_modules/@oino-ts/db/src/__snapshots__/OINODbApi.test.ts.snap.js", snapshot_file) // copy snapshots as .js so require works (note! if run with --update-snapshots, it's still the old file)
 const snapshots = require("./__snapshots__/OINODbApi.test.ts.snap.js")
 
-const api_crosschecks:string[] = [
-    "[HTTP GET] select *: GET JSON 1",
-    "[HTTP GET] select * with template: GET HTML 1",
-    "[HTTP POST] insert: GET JSON 1",
-    "[HTTP POST] insert: GET CSV 1",
-    "[HTTP PUT] update JSON: GET JSON 1",
-    "[HTTP PUT] update CSV: GET CSV 1",
-    "[HTTP PUT] update FORMDATA: GET FORMDATA 1",
-    "[HTTP PUT] update URLENCODE: GET URLENCODE 1"
-]
-
-const owasp_crosschecks:string[] = [
-    "[OWASP POST] POST: POST JSON 1",
-    "[OWASP PUT] PUT: OWASP PUT RESULT 1"
-]
-
-for (let i=0; i<dbs.length-1; i++) {
-    const db1:string = dbs[i].type
-    const db2:string = dbs[i+1].type
-    for (let api_test of api_tests) {
+for (let i=0; i<DATABASES.length-1; i++) {
+    const db1:string = DATABASES[i].type
+    const db2:string = DATABASES[i+1].type
+    for (let api_test of API_TESTS) {
         const table_name = api_test.apiParams.tableName
-        for (let crosscheck of api_crosschecks) {
+        for (let crosscheck of API_CROSSCHECKS) {
             test("cross check {" + db1 + "} and {" + db2 + "} table {" + table_name + "} snapshots on {" + crosscheck + "}", () => {
                 expect(snapshots["[" + api_test.name + "][" + db1 + "][" + table_name + "]" + crosscheck]).toMatch(snapshots["[" + api_test.name + "][" + db2 + "][" + table_name + "]" + crosscheck])
             })
         }        
     }
-    for (let owasp_test of owasp_tests) {
+    for (let owasp_test of OWASP_TESTS) {
         const table_name = owasp_test.apiParams.tableName
-        for (let crosscheck of owasp_crosschecks) {
+        for (let crosscheck of OWASP_CROSSCHECKS) {
             test("cross check {" + db1 + "} and {" + db2 + "} table {" + table_name + "} snapshots on {" + crosscheck + "}", () => {
                 expect(snapshots["[" + owasp_test.name + "][" + db1 + "][" + table_name + "]" + crosscheck]).toMatch(snapshots["[" + owasp_test.name + "][" + db2 + "][" + table_name + "]" + crosscheck])
             })