datagrok-tools 4.13.76 → 4.13.77

package/bin/commands/test.js

@@ -74,6 +74,7 @@ async function runTesting(args) {
   const parsed = (0, _orderFunctions.setAlphabeticalOrder)(testsObj, 1, 1);
   if (parsed.length == 0) return {
     failed: true,
+    error: '',
     verbosePassed: 'Package not found',
     verboseSkipped: 'Package not found',
     verboseFailed: 'Package not found',
@@ -145,8 +146,9 @@ async function runTesting(args) {
       testsResults.push(r);
       organized = testsLeft;
       browserId++;
-      if (r.verboseFailed === 'Tests execution failed') {
-        if (r.error) console.log(r.error);
+      if (r.error) {
+        console.log(`\nexecution error:`);
+        console.log(r.error);
         break;
       }
     } while (r.failed);

package/bin/utils/test-utils.js

@@ -90,22 +90,6 @@ async function getBrowserPage(puppeteer, params = defaultLaunchParameters) {
   url = await getWebUrl(url, token);
   console.log(`Using web root: ${url}`);
   const browser = await puppeteer.launch(params);
-  if (params.debug) {
-    const targets = await browser.targets();
-    const devtoolsTarget = targets.find(t => {
-      return t.type() === 'other' && t.url().startsWith('devtools://');
-    });
-    if (devtoolsTarget) {
-      const client = await devtoolsTarget.createCDPSession();
-      await client.send('Runtime.enable');
-      await client.send('Runtime.evaluate', {
-        expression: `
-      window.UI.viewManager.showView('network');
-      window.UI.dockController.setDockSide('bottom')
-    `
-      });
-    }
-  }
   const page = await browser.newPage();
   await page.setViewport({
     width: 1920,
@@ -320,7 +304,103 @@ function saveCsvResults(stringToSave, csvReportDir) {
   _fs.default.writeFileSync(csvReportDir, modifiedStrings.join('\n'), 'utf8');
   color.info('Saved `test-report.csv`\n');
 }
+async function helloTests(testsParams, stopOnFail) {
+  let failed = false;
+  let verbosePassed = "";
+  let verboseSkipped = "";
+  let verboseFailed = "";
+  let error = "";
+  let countPassed = 0;
+  let countSkipped = 0;
+  let countFailed = 0;
+  let resultDF = undefined;
+  let lastTest = null;
+  let res = '';
+  try {
+    for (let testParam of testsParams) {
+      lastTest = testParam;
+      let df = await window.grok.functions.call(testParam.package + ':test', testParam.params);
+      let flakingCol = window.DG.Column.fromType(window.DG.COLUMN_TYPE.BOOL, 'flaking', df.rowCount);
+      df.columns.add(flakingCol);
+      let packageNameCol = window.DG.Column.fromList(window.DG.COLUMN_TYPE.STRING, 'package', Array(df.rowCount).fill(testParam.package));
+      df.columns.add(packageNameCol);
+      if (df.rowCount === 0) {
+        verboseFailed += `Test result : Invocation Fail : ${testParam.params.category}: ${testParam.params.test}\n`;
+        countFailed += 1;
+        failed = true;
+        continue;
+      }
+      let row = df.rows.get(0);
+      if (df.rowCount > 1) {
+        let unhandledErrorRow = df.rows.get(1);
+        if (!unhandledErrorRow.get("success")) {
+          unhandledErrorRow["category"] = row.get("category");
+          unhandledErrorRow["name"] = row.get("name");
+          row = unhandledErrorRow;
+        }
+      }
+      const category = row.get("category");
+      const testName = row.get("name");
+      const time = row.get("ms");
+      const result = row.get("result");
+      const success = row.get("success");
+      const skipped = row.get("skipped");
+      row["flaking"] = success && window.DG.Test.isReproducing;
+      df.changeColumnType('result', window.DG.COLUMN_TYPE.STRING);
+      df.changeColumnType('logs', window.DG.COLUMN_TYPE.STRING);
+      df.changeColumnType('memoryDelta', window.DG.COLUMN_TYPE.BIG_INT);
+      if (resultDF === undefined) resultDF = df;else resultDF = resultDF.append(df);
+      if (row["skipped"]) {
+        verboseSkipped += `Test result : Skipped : ${time} : ${category}: ${testName} :  ${result}\n`;
+        countSkipped += 1;
+      } else if (row["success"]) {
+        verbosePassed += `Test result : Success : ${time} : ${category}: ${testName} :  ${result}\n`;
+        countPassed += 1;
+      } else {
+        verboseFailed += `Test result : Failed : ${time} : ${category}: ${testName} :  ${result}\n`;
+        countFailed += 1;
+        failed = true;
+      }
+      if (success !== true && skipped !== true && stopOnFail) break;
+    }
+    if (window.DG.Test.isInDebug) {
+      console.log('on browser closing debug point');
+      debugger;
+    }
+    res = '';
+    if (resultDF) {
+      const bs = window.DG.BitSet.create(resultDF.rowCount);
+      bs.setAll(true);
+      for (let i = 0; i < resultDF.rowCount; i++) {
+        if (resultDF.rows.get(i).get('category') === 'Unhandled exceptions') {
+          bs.set(i, false);
+        }
+      }
+      resultDF = resultDF.clone(bs);
+      res = resultDF.toCsv();
+    }
+  } catch (e) {
+    failed = true;
+    error = lastTest ? `category: ${lastTest.params.category}, name: ${lastTest.params.test}, error: ${e}, ${await window.DG.Logger.translateStackTrace(e.stack)}` : `test: null, error: ${e}, ${await window.DG.Logger.translateStackTrace(e.stack)}`;
+  }
+  return {
+    failed: failed,
+    verbosePassed: verbosePassed,
+    verboseSkipped: verboseSkipped,
+    verboseFailed: verboseFailed,
+    passedAmount: countPassed,
+    skippedAmount: countSkipped,
+    failedAmount: countFailed,
+    error: error,
+    csv: res
+    // df: resultDF?.toJson()
+  };
+}
 async function runBrowser(testExecutionData, browserOptions, browsersId, testInvocationTimeout = 3600000) {
+  let testsToRun = {
+    func: helloTests.toString(),
+    tests: testExecutionData
+  };
   return await timeout(async () => {
     const params = Object.assign({
       devtools: browserOptions.debug
@@ -347,29 +427,49 @@ async function runBrowser(testExecutionData, browserOptions, browsersId, testInv
         addLogsToFile(logsDir, `CONSOLE LOG REQUEST: ${response.status()}, ${response.url()}\n`);
       });
     }
-    const testingResults = await page.evaluate(async (testData, options) => {
-      try {
-        if (options.benchmark) window.DG.Test.isInBenchmark = true;
-        if (options.reproduce) window.DG.Test.isReproducing = true;
-        if (options.ciCd) window.DG.Test.isCiCd = true;
-        if (options.debug) window.DG.Test.isInDebug = true;
-        const results = await window.DG.Utils.executeTests(testData, options.stopOnTimeout);
-        return results;
-      } catch (e) {
-        return {
-          failed: true,
-          verbosePassed: "",
-          verboseSkipped: "",
-          verboseFailed: "Tests execution failed",
-          error: JSON.stringify(e),
-          passedAmount: 0,
-          skippedAmount: 0,
-          failedAmount: 1,
-          csv: "",
-          df: undefined
-        };
-      }
-    }, testExecutionData, browserOptions);
+    let testingResults = await page.evaluate((testData, options) => {
+      if (options.benchmark) window.DG.Test.isInBenchmark = true;
+      if (options.reproduce) window.DG.Test.isReproducing = true;
+      if (options.ciCd) window.DG.Test.isCiCd = true;
+      if (options.debug) window.DG.Test.isInDebug = true;
+      return new Promise((resolve, reject) => {
+        window.helloTests = eval('(' + testData.func + ')');
+        window.helloTests(testData.tests, options.stopOnTimeout).then(results => {
+          resolve(results);
+        }).catch(e => {
+          resolve({
+            failed: true,
+            verbosePassed: "",
+            verboseSkipped: "",
+            verboseFailed: "",
+            error: JSON.stringify(e),
+            passedAmount: 0,
+            skippedAmount: 0,
+            failedAmount: 1,
+            csv: "",
+            df: undefined
+          });
+        });
+
+        // (<any>window).DG.Utils.executeTests(testData.tests, options.stopOnTimeout)
+        //   .then((results: any) => {
+        //     resolve(results);
+        //   })
+        //   .catch((e: any) => {
+        //     resolve({
+        //       failed: true,
+        //       verbosePassed: "",
+        //       verboseSkipped: "",
+        //       verboseFailed: "Tests execution failed",
+        //       passedAmount: 0,
+        //       skippedAmount: 0,
+        //       failedAmount: 1,
+        //       csv: "",
+        //       df: undefined
+        //     })
+        //   });
+      });
+    }, testsToRun, browserOptions);
     if (browserOptions.record) {
       await recorder.stop();
     }
@@ -388,7 +488,8 @@ async function mergeBrowsersResults(browsersResults) {
     passedAmount: browsersResults[0].passedAmount,
     skippedAmount: browsersResults[0].skippedAmount,
     failedAmount: browsersResults[0].failedAmount,
-    csv: browsersResults[0].csv
+    csv: browsersResults[0].csv,
+    error: ''
   };
   for (let browsersResult of browsersResults) {
     if (mergedResult.csv === browsersResult.csv) continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "datagrok-tools",
-  "version": "4.13.76",
+  "version": "4.13.77",
   "description": "Utility to upload and publish packages to Datagrok",
   "homepage": "https://github.com/datagrok-ai/public/tree/master/tools#readme",
   "dependencies": {