datagrok-tools 5.0.0 → 5.1.2

package/bin/commands/help.js

@@ -119,6 +119,7 @@ Options:
 --build  	        Builds the package
 --release         Publish package as release version
 --skip-check      Skip check stage 
+--verbose         Show debug information
 
 Running \`grok publish\` is the same as running \`grok publish defaultHost --build --debug\`
 `;
@@ -146,13 +147,13 @@ Options:
 --csv               Save the test report in a CSV file
 --gui               Launch graphical interface (non-headless mode)
 --debug             Enables debug point on tests run (useless without gui mode) 
---catchUnhandled    Catch unhandled exceptions during test execution (default=true)
+--verbose           Show debug information
+--retry --no-retry  Enables or disables browser reload after a failed test
 --report            Report failed tests to audit, notifies package author (default=false)
 --skip-build        Skip the package build step
 --skip-publish      Skip the package publication step
---link  	          Link the package to local utils
+--link  	        Link the package to local utils
 --record            Records the test execution process in mp4 format
---verbose           Prints detailed information about passed and skipped tests in the console
 --platform          Runs only platform tests (applicable for ApiTests package only)
 --core              Runs package & auto tests & core tests (core tests run only from DevTools package)
 --benchmark   	    Runs tests in benchmark mode

package/bin/commands/publish.js

@@ -35,8 +35,9 @@ let curDir = process.cwd();
 const packDir = _path.default.join(curDir, 'package.json');
 const packageFiles = ['src/package.ts', 'src/detectors.ts', 'src/package.js', 'src/detectors.js', 'src/package-test.ts', 'src/package-test.js', 'package.js', 'detectors.js'];
 let config;
-async function processPackage(debug, rebuild, host, devKey, packageName, dropDb, suffix) {
+async function processPackage(debug, rebuild, host, devKey, packageName, dropDb, suffix, verbose) {
   // Get the server timestamps
+  verbose = verbose || false;
   let timestamps = {};
   let url = `${host}/packages/dev/${devKey}/${packageName}`;
   if (debug) {
@@ -47,13 +48,16 @@ async function processPackage(debug, rebuild, host, devKey, packageName, dropDb,
         return 1;
       }
     } catch (error) {
-      console.error(error);
+      if (utils.isConnectivityError(error)) color.error(`Server is possibly offline: ${host}`);
+      if (verbose) console.error(error);
       return 1;
     }
   }
   const zip = (0, _archiverPromise.default)('zip', {
     store: false
   });
+  const chunks = [];
+  zip.on('data', chunk => chunks.push(chunk));
 
   // Gather the files
   const localTimestamps = {};
@@ -130,7 +134,6 @@ async function processPackage(debug, rebuild, host, devKey, packageName, dropDb,
     const t = _fs.default.statSync(fullPath).mtime.toUTCString();
     localTimestamps[canonicalRelativePath] = t;
     if (debug && timestamps[canonicalRelativePath] === t) {
-      console.log(`Skipping ${canonicalRelativePath}`);
       return;
     }
     if (canonicalRelativePath.startsWith('connections/')) {
@@ -149,13 +152,11 @@ async function processPackage(debug, rebuild, host, devKey, packageName, dropDb,
       zip.append(f, {
         name: relativePath
       });
-      console.log(`Adding ${canonicalRelativePath}...`);
       return;
     }
     zip.append(_fs.default.createReadStream(fullPath), {
       name: relativePath
     });
-    console.log(`Adding ${canonicalRelativePath}...`);
   });
   if (errs.length) {
     errs.forEach(e => color.error(e));
@@ -168,37 +169,27 @@ async function processPackage(debug, rebuild, host, devKey, packageName, dropDb,
   // Upload
   url += `?debug=${debug.toString()}&rebuild=${rebuild.toString()}&dropDb=${(dropDb ?? false).toString()}`;
   if (suffix) url += `&suffix=${suffix.toString()}`;
-  const uploadPromise = new Promise((resolve, reject) => {
-    (0, _nodeFetch.default)(url, {
-      method: 'POST',
-      body: zip
-    }).then(async body => {
-      let response;
-      try {
-        response = await body.text();
-        return JSON.parse(response);
-      } catch (error) {
-        console.error(response);
-      }
-    }).then(j => resolve(j)).catch(err => {
-      reject(err);
-    });
-  }).catch(error => {
-    console.error(error);
-  });
   await zip.finalize();
+  const zipBuffer = Buffer.concat(chunks);
   try {
-    const log = await uploadPromise;
+    const body = await (0, _nodeFetch.default)(url, {
+      method: 'POST',
+      body: zipBuffer
+    });
+    const log = JSON.parse(await body.text());
     _fs.default.unlinkSync('zip');
-    if (log['#type'] === 'ApiError') {
-      color.error(log['message']);
-      console.error(log['innerMessage']);
-      console.log(log);
-      return 1;
-    } else console.log(log);
-    // color.warn(contentValidationLog);
+    if (log != undefined) {
+      if (log['#type'] === 'ApiError') {
+        color.error(log['message']);
+        console.error(log['innerMessage']);
+        console.log(log);
+        return 1;
+      } else console.log(log);
+      // color.warn(contentValidationLog);
+    }
   } catch (error) {
-    console.error(error);
+    if (utils.isConnectivityError(error)) color.error(`Server is possibly offline: ${url}`);
+    if (verbose) console.error(error);
     return 1;
   }
   return 0;
@@ -248,15 +239,15 @@ async function publishPackage(args) {
   if (!args.link) {
     if (args.build || args.rebuild) {
       console.log('Building');
-      utils.runScript('npm install', curDir, false);
-      utils.runScript('npm run build', curDir, false);
+      await utils.runScript('npm install', curDir, false);
+      await utils.runScript('npm run build', curDir, false);
     }
   }
   if (args.debug && args.release) {
     color.error('Incompatible options: --debug and --release');
     return false;
   }
-  console.log('Publishing');
+  console.log('Publishing...');
   // Create `config.yaml` if it doesn't exist yet
   if (!_fs.default.existsSync(grokDir)) _fs.default.mkdirSync(grokDir);
   if (!_fs.default.existsSync(confPath)) _fs.default.writeFileSync(confPath, _jsYaml.default.dump(confTemplate));
@@ -305,7 +296,7 @@ async function publishPackage(args) {
         if (!args.suffix && stdout) args.suffix = stdout.toString().substring(0, 8);
       });
       await utils.delay(100);
-      code = await processPackage(!args.release, Boolean(args.rebuild), url, key, packageName, args.dropDb ?? false, args.suffix);
+      code = await processPackage(!args.release, Boolean(args.rebuild), url, key, packageName, args.dropDb ?? false, args.suffix, args.verbose);
     } catch (error) {
       console.error(error);
       code = 1;

package/bin/commands/test.js

@@ -42,7 +42,14 @@ async function test(args) {
   //   color.warn('--core flag can only be used in the DevTools package');
 
   if (!args.package) {
-    await testUtils.loadPackages(packagesDir, packageName, args.host, args['skip-publish'], args['skip-build'], args.link);
+    try {
+      await testUtils.loadPackages(packagesDir, packageName, args.host, args['skip-publish'], args['skip-build'], args.link);
+    } catch (e) {
+      console.error('\n');
+      // @ts-ignore
+      console.error(e.message);
+      process.exit(1);
+    }
   }
   process.env.TARGET_PACKAGE = packageName;
   const res = await runTesting(args);
@@ -71,6 +78,7 @@ const MAX_RETRIES_PER_SESSION = 10;
 let retryEnabled = true;
 async function runTesting(args) {
   retryEnabled = args['retry'] ?? true;
+  if (args.test || args.category) retryEnabled = false;
   let organized = {
     package: process.env.TARGET_PACKAGE ?? '',
     params: {

package/bin/utils/test-utils.js

@@ -47,9 +47,15 @@ const defaultLaunchParameters = exports.defaultLaunchParameters = {
   protocolTimeout: 0
 };
 async function getToken(url, key) {
-  const response = await fetch(`${url}/users/login/dev/${key}`, {
-    method: 'POST'
-  });
+  let response;
+  try {
+    response = await fetch(`${url}/users/login/dev/${key}`, {
+      method: 'POST'
+    });
+  } catch (error) {
+    if (utils.isConnectivityError(error)) color.error(`Server is possibly offline: ${url}`);
+    throw error;
+  }
   const json = await response.json();
   if (json.isSuccess == true) return json.token;else throw new Error('Unable to login to server. Check your dev key');
 }
@@ -190,17 +196,13 @@ const recorderConfig = exports.recorderConfig = {
   // aspectRatio: '16:9',
 };
 async function loadPackage(packageDir, dirName, hostString, skipPublish, skipBuild, linkPackage, release) {
-  try {
-    if (skipPublish != true) {
-      process.stdout.write(`Building and publishing ${dirName}...`);
-      await utils.runScript(`npm install`, packageDir);
-      if (linkPackage) await utils.runScript(`grok link`, packageDir);
-      if (skipBuild != true) await utils.runScript(`npm run build`, packageDir);
-      await utils.runScript(`grok publish ${hostString}${release ? ' --release' : ''}`, packageDir);
-      process.stdout.write(` success!\n`);
-    }
-  } catch (e) {
-    process.stdout.write(` failed to load package ${dirName}!\n`);
+  if (skipPublish != true) {
+    process.stdout.write(`Building and publishing ${dirName}...`);
+    await utils.runScript(`npm install`, packageDir);
+    if (linkPackage) await utils.runScript(`grok link`, packageDir);
+    if (skipBuild != true) await utils.runScript(`npm run build`, packageDir);
+    await utils.runScript(`grok publish ${hostString}${release ? ' --release' : ''}`, packageDir);
+    process.stdout.write(` success!\n`);
   }
 }
 async function loadPackages(packagesDir, packagesToLoad, host, skipPublish, skipBuild, linkPackage, release) {
@@ -214,18 +216,20 @@ async function loadPackages(packagesDir, packagesToLoad, host, skipPublish, skip
   for (const dirName of _fs.default.readdirSync(packagesDir)) {
     const packageDir = _path.default.join(packagesDir, dirName);
     if (!_fs.default.lstatSync(packageDir).isFile()) {
+      let shouldLoad = false;
       try {
         const packageJsonData = JSON.parse(_fs.default.readFileSync(_path.default.join(packageDir, 'package.json'), {
           encoding: 'utf-8'
         }));
         const packageFriendlyName = packagesToRun.get((0, _utils.spaceToCamelCase)(packageJsonData['friendlyName'] ?? packageJsonData['name'].split('/')[1] ?? packageJsonData['name'] ?? '').toLocaleLowerCase() ?? '') ?? packagesToRun.get(dirName);
-        if (utils.isPackageDir(packageDir) && (packageFriendlyName !== undefined || packagesToLoad === 'all')) {
-          await loadPackage(packageDir, dirName, hostString, skipPublish, skipBuild, linkPackage, release);
-          packagesToRun.set(dirName, true);
-        }
+        shouldLoad = utils.isPackageDir(packageDir) && (packageFriendlyName !== undefined || packagesToLoad === 'all');
       } catch (e) {
         if (utils.isPackageDir(packageDir) && (packagesToRun.get((0, _utils.spaceToCamelCase)(dirName).toLocaleLowerCase()) !== undefined || packagesToLoad === 'all')) console.log(`Couldn't read package.json  ${dirName}`);
       }
+      if (shouldLoad) {
+        await loadPackage(packageDir, dirName, hostString, skipPublish, skipBuild, linkPackage, release);
+        packagesToRun.set(dirName, true);
+      }
     }
   }
   console.log();
@@ -332,6 +336,15 @@ function printBrowsersResult(browserResult, verbose = false) {
     if ((browserResult.failedAmount ?? 0) > 0 && (browserResult.verboseFailed ?? []).length > 0) {
       console.log('Failed: ');
       console.log(browserResult.verboseFailed);
+      for (const line of browserResult.verboseFailed.split('\n')) {
+        const match = line.match(/^(.+?):\s+(.+?)\s+\(/);
+        if (match) {
+          const category = match[1].trim();
+          const testName = match[2].trim();
+          if (testName === 'before' || testName === 'after') console.log(`\x1b[33m  To run this category separately use --category "${category}" argument\x1b[0m`);else console.log(`\x1b[33m  To run this test separately use --category "${category}" --test "${testName}" arguments\x1b[0m`);
+          console.log('');
+        }
+      }
     }
     console.log('Passed amount:  ' + browserResult?.passedAmount);
     console.log('Skipped amount: ' + browserResult?.skippedAmount);
@@ -619,39 +632,62 @@ async function runBrowser(testExecutionData, browserOptions, browsersId, testInv
     let currentTestName = null;
     // Store failed tests with their errors to print after category header
     let pendingFailures = [];
+    let pendingSkipped = [];
     let pendingBeforeFailure = null;
     let pendingAfterFailure = null;
     let modernOutput = false;
     const printCategorySummary = category => {
       const results = categoryResults.get(category);
       if (!results) return;
-      const formattedCategory = category.replace(/: /g, ', ');
+      const formattedCategory = category;
       const passedCount = results.passed;
+      const skippedSuffix = results.skipped > 0 ? `, \x1b[33m${results.skipped} skipped\x1b[0m` : '';
       if (results.failed > 0 || pendingBeforeFailure || pendingAfterFailure) {
-        console.log(`\x1b[31m❌ ${formattedCategory} (${passedCount} passed)\x1b[0m`);
+        console.log(`\x1b[31m❌ ${formattedCategory}\x1b[31m (\x1b[32m${passedCount} passed${skippedSuffix}\x1b[31m)\x1b[0m`);
         // Print before() failure first
         if (pendingBeforeFailure) {
           console.log(`  \x1b[31m❌ before\x1b[0m`);
           if (pendingBeforeFailure.error) console.log(`    \x1b[31m${pendingBeforeFailure.error}\x1b[0m`);
+          console.log(`    \x1b[33mTo run this category separately use --category "${category}"\x1b[0m`);
         }
         // Print after() failure
         if (pendingAfterFailure) {
           console.log(`  \x1b[31m❌ after\x1b[0m`);
           if (pendingAfterFailure.error) console.log(`    \x1b[31m${pendingAfterFailure.error}\x1b[0m`);
+          console.log(`    \x1b[33mTo run this category separately use --category "${category}"\x1b[0m`);
         }
+        // Print skipped tests
+        for (const skippedName of pendingSkipped) console.log(`  \x1b[33m⊘ ${skippedName}\x1b[0m`);
         // Print test failures
         for (const failure of pendingFailures) {
           console.log(`  \x1b[31m❌ ${failure.testName}\x1b[0m`);
           if (failure.error) console.log(`    \x1b[31m${failure.error}\x1b[0m`);
+          console.log(`    \x1b[33mTo run this test separately use --category "${category}" --test "${failure.testName}"\x1b[0m`);
         }
       } else {
-        console.log(`\x1b[32m✅ ${formattedCategory} (${passedCount} passed)\x1b[0m`);
+        console.log(`\x1b[32m✅ ${formattedCategory} (${passedCount} passed${skippedSuffix}\x1b[32m)\x1b[0m`);
+        // Print skipped tests
+        for (const skippedName of pendingSkipped) console.log(`  \x1b[33m⊘ ${skippedName}\x1b[0m`);
       }
       pendingFailures = [];
+      pendingSkipped = [];
       pendingBeforeFailure = null;
       pendingAfterFailure = null;
     };
 
+    // Print all console messages when verbose mode is enabled
+    if (browserOptions.verbose) {
+      page.on('console', msg => {
+        const type = msg.type();
+        const text = msg.text();
+        if (text.startsWith('Package testing: ')) return;
+        if (type === 'error') console.log(`\x1b[31m[console.error] ${text}\x1b[0m`);else if (type === 'warning') console.log(`\x1b[33m[console.warn] ${text}\x1b[0m`);else console.log(`[console.log] ${text}`);
+      });
+      page.on('pageerror', error => {
+        console.log(`\x1b[31m[page error] ${error.message}\x1b[0m`);
+      });
+    }
+
     // Subscribe to page console events for modern output formatting
     // On retry, old listeners were removed so we need to re-attach
     page.on('console', msg => {
@@ -664,21 +700,28 @@ async function runBrowser(testExecutionData, browserOptions, browsersId, testInv
       let match;
       while ((match = tokenRegex.exec(text)) !== null) tokens.push(match[1]);
 
-      // Category start: "Package testing: Started {{Category}}"
-      if (text.includes('Started') && tokens.length === 1) {
+      // Category start: "Package testing: Started {{Category}}" or "Package testing: Started {{Category}} skipped {{N}}"
+      if (text.includes('Started') && (tokens.length === 1 || tokens.length === 2 && text.includes('skipped'))) {
         // Print summary of previous category if exists
         if (currentCategory && categoryResults.has(currentCategory)) printCategorySummary(currentCategory);
         currentCategory = tokens[0];
+        const skippedCount = tokens.length === 2 ? parseInt(tokens[1]) || 0 : 0;
         categoryResults.set(currentCategory, {
           passed: 0,
-          failed: 0
+          failed: 0,
+          skipped: skippedCount
         });
         pendingFailures = [];
+        pendingSkipped = [];
         pendingBeforeFailure = null;
         pendingAfterFailure = null;
+      } else if (text.includes('Skipped') && tokens.length === 2 && !text.includes('benchmark')) {
+        // Individual skipped test: "Package testing: Skipped {{Category}} {{TestName}}"
+        // Only collect if the test belongs to the current active category
+        if (tokens[0] === currentCategory) pendingSkipped.push(tokens[1]);
       } else if (text.includes('Started') && tokens.length === 2) {
         // Test start: "Package testing: Started {{Category}} {{TestName}}"
-        const category = tokens[0].replace(/: /g, ', ');
+        const category = tokens[0];
         currentTestName = tokens[1];
         process.stdout.write(`${category}: ${currentTestName}...`);
       } else if (text.includes('Finished') && tokens.length === 3) {
@@ -689,7 +732,7 @@ async function runBrowser(testExecutionData, browserOptions, browsersId, testInv
         const results = categoryResults.get(category);
 
         // Clear the current test line
-        process.stdout.write('\r\x1b[K');
+        if (!browserOptions.verbose) process.stdout.write('\r\x1b[K');
         if (status === 'success') {
           if (results) results.passed++;
         } else {

package/bin/utils/utils.js

@@ -18,6 +18,7 @@ exports.getScriptInputs = getScriptInputs;
 exports.getScriptName = getScriptName;
 exports.getScriptOutputType = getScriptOutputType;
 exports.headerTags = void 0;
+exports.isConnectivityError = isConnectivityError;
 exports.isEmpty = isEmpty;
 exports.isPackageDir = isPackageDir;
 exports.isValidCron = isValidCron;
@@ -260,6 +261,10 @@ const queryWrapperTemplate = exports.queryWrapperTemplate = `#{FUNC_DESCRIPTION}
   return await grok.data.query('#{PACKAGE_NAMESPACE}:#{FUNC_NAME}', #{PARAMS_OBJECT});
 }`;
 const namespaceTemplate = exports.namespaceTemplate = `export namespace #{PACKAGE_NAMESPACE} {\n#{NAME}\n}`;
+function isConnectivityError(error) {
+  const msg = (error?.message ?? '').toLowerCase() + ' ' + (error?.code ?? '').toLowerCase();
+  return ['econnrefused', 'enotfound', 'etimedout', 'eai_again', 'econnreset', 'fetch failed', 'network error'].some(token => msg.includes(token));
+}
 async function runScript(script, path, verbose = false) {
   try {
     const {
@@ -271,8 +276,8 @@ async function runScript(script, path, verbose = false) {
     if (stderr && verbose) console.error(`Warning/Error: ${stderr}`);
     if (stdout && verbose) console.log(`Output: ${stdout}`);
   } catch (error) {
-    console.error(`Execution failed: ${error.message}`);
-    throw new Error(`Error executing '${script}'. Error message: ${error.message}`);
+    const output = [error.stdout, error.stderr].filter(Boolean).join('\n');
+    throw new Error(output);
   }
 }
 function setHost(host, configFile) {

package/package-template/package.json

@@ -15,11 +15,11 @@
     "webpack-cli": "^5.1.4"
   },
   "scripts": {
-    "link-all": "grok link",
     "debug-#{PACKAGE_NAME_LOWERCASE}": "webpack && grok publish",
     "release-#{PACKAGE_NAME_LOWERCASE}": "webpack && grok publish --release",
     "build-#{PACKAGE_NAME_LOWERCASE}": "webpack",
-    "build": "grok api && grok check && webpack"
+    "build": "grok api && grok check && webpack",
+    "test": "grok test"
   },
   "canEdit": [
     "Developers"

package/package-template/ts.webpack.config.js

@@ -12,6 +12,7 @@ module.exports = {
     package: './src/package.ts',
   },
   resolve: {
+    symlinks: false,
     extensions: ['.wasm', '.mjs', '.ts', '.json', '.js', '.tsx'],
   },
   module: {

package/package.json

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