datagrok-tools 4.13.21 → 4.13.22

package/CHANGELOG.md

@@ -1,6 +1,12 @@
 # Datagrok-tools changelog
 
 
+## 4.13.22 (2024-09-20)
+
+### Features
+
+* Implemented mechanism which allows to test few packages by one function
+
 ## 4.13.21 (2024-09-17)
 
 ### Features

package/bin/commands/link.js

@@ -12,12 +12,10 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _fs = _interopRequireDefault(require("fs"));
 var _path = _interopRequireDefault(require("path"));
-var _child_process = require("child_process");
-var _util = require("util");
+var _utils = require("../utils/utils");
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } /* eslint-disable valid-jsdoc */
-var execAsync = (0, _util.promisify)(_child_process.exec);
 var repositoryDirNameRegex = new RegExp(_path["default"].join('1', '2')[1] + 'public$');
 var curDir = process.cwd();
 var devMode = false;
@@ -122,13 +120,13 @@ function _linkPackages() {
           }
           element = _step.value;
           _context2.next = 11;
-          return runScript("npm install", element.packagePath);
+          return (0, _utils.runScript)("npm install", element.packagePath);
         case 11:
           _context2.next = 13;
-          return runScript("npm link ".concat(element.dependencies.join(' ')), element.packagePath);
+          return (0, _utils.runScript)("npm link ".concat(element.dependencies.join(' ')), element.packagePath);
         case 13:
           _context2.next = 15;
-          return runScript("npm link", element.packagePath);
+          return (0, _utils.runScript)("npm link", element.packagePath);
         case 15:
           packagesToLink["delete"](element.name);
           anyChanges = true;
@@ -160,10 +158,10 @@ function _linkPackages() {
             return x.name;
           });
           _context2.next = 34;
-          return runScript("npm install", curDir);
+          return (0, _utils.runScript)("npm install", curDir);
         case 34:
           _context2.next = 36;
-          return runScript("npm link ".concat(names.join(' ')), curDir);
+          return (0, _utils.runScript)("npm link ".concat(names.join(' ')), curDir);
         case 36:
         case "end":
           return _context2.stop();
@@ -172,43 +170,6 @@ function _linkPackages() {
   }));
   return _linkPackages.apply(this, arguments);
 }
-function runScript(_x2, _x3) {
-  return _runScript.apply(this, arguments);
-}
-function _runScript() {
-  _runScript = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(script, path) {
-    var _yield$execAsync, stdout, stderr;
-    return _regenerator["default"].wrap(function _callee3$(_context3) {
-      while (1) switch (_context3.prev = _context3.next) {
-        case 0:
-          _context3.prev = 0;
-          _context3.next = 3;
-          return execAsync(script, {
-            cwd: path
-          });
-        case 3:
-          _yield$execAsync = _context3.sent;
-          stdout = _yield$execAsync.stdout;
-          stderr = _yield$execAsync.stderr;
-          if (stderr) {
-            console.error("Error: ".concat(stderr));
-          } else {
-            // console.log(`Output: ${stdout}`);
-          }
-          _context3.next = 12;
-          break;
-        case 9:
-          _context3.prev = 9;
-          _context3.t0 = _context3["catch"](0);
-          console.error("Execution failed: ".concat(_context3.t0.message));
-        case 12:
-        case "end":
-          return _context3.stop();
-      }
-    }, _callee3, null, [[0, 9]]);
-  }));
-  return _runScript.apply(this, arguments);
-}
 var PackageData = /*#__PURE__*/(0, _createClass2["default"])(function PackageData(name, packagePath) {
   (0, _classCallCheck2["default"])(this, PackageData);
   (0, _defineProperty2["default"])(this, "name", void 0);

package/bin/commands/test-all.js

@@ -0,0 +1,694 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.testAll = testAll;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+var _fs = _interopRequireDefault(require("fs"));
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var _puppeteer = _interopRequireDefault(require("puppeteer"));
+var _puppeteerScreenRecorder = require("puppeteer-screen-recorder");
+var _jsYaml = _interopRequireDefault(require("js-yaml"));
+var color = _interopRequireWildcard(require("../utils/color-utils"));
+var testUtils = _interopRequireWildcard(require("../utils/test-utils"));
+var _utils = require("../utils/utils");
+var _orderFunctions = require("../utils/order-functions");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } /* eslint-disable max-len */
+var order = /*#__PURE__*/function (order) {
+  order[order["random"] = 0] = "random";
+  order[order["alphabetical"] = 1] = "alphabetical";
+  order[order["packageRandom"] = 2] = "packageRandom";
+  order[order["packageAlphabetical"] = 3] = "packageAlphabetical";
+  return order;
+}(order || {});
+function getEnumOrder(orderStr) {
+  switch (orderStr.toLowerCase().replaceAll("-", "")) {
+    case "random":
+    case "shuffle":
+      return order.random;
+      break;
+    case "alphabetical":
+    case "atoz":
+      return order.alphabetical;
+      break;
+    case "packagerandom":
+    case "packageshuffle":
+      return order.packageRandom;
+      break;
+    case "packagealphabetical":
+    case "packageatoz":
+      return order.packageAlphabetical;
+      break;
+  }
+  return order.random;
+}
+var grokDir = _path["default"].join(_os["default"].homedir(), '.grok');
+var confPath = _path["default"].join(grokDir, 'config.yaml');
+var config = _jsYaml["default"].load(_fs["default"].readFileSync(confPath, {
+  encoding: 'utf-8'
+}));
+var curDir = process.cwd();
+var testCollectionTimeout = 100000;
+var testInvocationTimeout = 3600000;
+var orderingFunctions = new Map([[order.random, _orderFunctions.setRandomOrder], [order.alphabetical, _orderFunctions.setAlphabeticalOrder], [order.packageRandom, _orderFunctions.setPackageRandomOrder], [order.packageAlphabetical, _orderFunctions.setPackageAlphabeticalOrder]]);
+var workersStarted = 0;
+function testAll(_x) {
+  return _testAll.apply(this, arguments);
+}
+function _testAll() {
+  _testAll = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(args) {
+    var _args$tags, _args$order, _args$benchmark, _args$catchUnhandled, _args$gui, _args$record, _args$report, _args$verbose;
+    var builtPackages, packagesToRun, testsObj, filteredTests, workersOrder, testsResults, i, _iterator, _step, result;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          setHost(args);
+          _context.next = 3;
+          return buildPackages(args.packages, args.host, args['skip-publish'], args['skip-build']);
+        case 3:
+          builtPackages = _context.sent;
+          packagesToRun = [];
+          builtPackages.forEach(function (value, key) {
+            if (value) {
+              packagesToRun.push(key);
+            }
+          });
+          _context.next = 8;
+          return loadTestsList(packagesToRun, args.core);
+        case 8:
+          testsObj = _context.sent;
+          _context.next = 11;
+          return filterTests(testsObj, ((_args$tags = args.tags) !== null && _args$tags !== void 0 ? _args$tags : "").split(" "), args['stress-test'], args.benchmark);
+        case 11:
+          filteredTests = _context.sent;
+          _context.next = 14;
+          return setWorkersOrder(filteredTests, getEnumOrder((_args$order = args.order) !== null && _args$order !== void 0 ? _args$order : ''), args.workersCount, args.testRepeat);
+        case 14:
+          workersOrder = _context.sent;
+          console.log(filteredTests);
+          _context.next = 18;
+          return runTests(workersOrder, {
+            benchmark: (_args$benchmark = args.benchmark) !== null && _args$benchmark !== void 0 ? _args$benchmark : false,
+            catchUnhandled: (_args$catchUnhandled = args.catchUnhandled) !== null && _args$catchUnhandled !== void 0 ? _args$catchUnhandled : false,
+            gui: (_args$gui = args.gui) !== null && _args$gui !== void 0 ? _args$gui : false,
+            record: (_args$record = args.record) !== null && _args$record !== void 0 ? _args$record : false,
+            report: (_args$report = args.report) !== null && _args$report !== void 0 ? _args$report : false,
+            verbose: (_args$verbose = args.verbose) !== null && _args$verbose !== void 0 ? _args$verbose : false
+          });
+        case 18:
+          testsResults = _context.sent;
+          i = 0;
+          _iterator = _createForOfIteratorHelper(testsResults);
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              result = _step.value;
+              console.log("\nWorker #".concat(i++, " "));
+              printWorkersResult(result, args.verbose);
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+          return _context.abrupt("return", !testsResults.map(function (test) {
+            return test.failed;
+          }).some(function (failStatus) {
+            return failStatus === true;
+          }));
+        case 23:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _testAll.apply(this, arguments);
+}
+function setHost(args) {
+  if (args.host) {
+    if (args.host in config.servers) {
+      process.env.HOST = args.host;
+      console.log('Environment variable `HOST` is set to', args.host);
+    } else {
+      color.error("Unknown server alias. Please add it to ".concat(confPath));
+      return false;
+    }
+  } else if (config["default"]) {
+    process.env.HOST = config["default"];
+    console.log('Environment variable `HOST` is set to', config["default"]);
+  }
+}
+function buildPackages(_x2, _x3, _x4, _x5, _x6) {
+  return _buildPackages.apply(this, arguments);
+}
+function _buildPackages() {
+  _buildPackages = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(packages, host, skipPublish, skipBuild, linkPackage) {
+    var packagesToRun, hostString, _iterator2, _step2, pacakgeName, _iterator3, _step3, dirName, packageDir;
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          packagesToRun = new Map();
+          hostString = host === undefined ? "" : "".concat(host);
+          if (packages !== "all") {
+            _iterator2 = _createForOfIteratorHelper((packages !== null && packages !== void 0 ? packages : "").split(' '));
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                pacakgeName = _step2.value;
+                packagesToRun.set(pacakgeName, false);
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+          }
+          _iterator3 = _createForOfIteratorHelper(_fs["default"].readdirSync(curDir));
+          _context2.prev = 4;
+          _iterator3.s();
+        case 6:
+          if ((_step3 = _iterator3.n()).done) {
+            _context2.next = 26;
+            break;
+          }
+          dirName = _step3.value;
+          packageDir = _path["default"].join(curDir, dirName);
+          if (_fs["default"].lstatSync(packageDir).isFile()) {
+            _context2.next = 24;
+            break;
+          }
+          if (!((0, _utils.isPackageDir)(packageDir) && (packagesToRun.get(dirName) !== undefined || packages === "all"))) {
+            _context2.next = 24;
+            break;
+          }
+          if (!(skipPublish != true)) {
+            _context2.next = 22;
+            break;
+          }
+          _context2.next = 14;
+          return (0, _utils.runScript)("npm install", packageDir);
+        case 14:
+          if (!linkPackage) {
+            _context2.next = 17;
+            break;
+          }
+          _context2.next = 17;
+          return (0, _utils.runScript)("grok link", packageDir);
+        case 17:
+          if (!(skipBuild != true)) {
+            _context2.next = 20;
+            break;
+          }
+          _context2.next = 20;
+          return (0, _utils.runScript)("npm run build", packageDir);
+        case 20:
+          _context2.next = 22;
+          return (0, _utils.runScript)("grok publish ".concat(hostString), packageDir);
+        case 22:
+          packagesToRun.set(dirName, true);
+          console.log("Package published ".concat(dirName));
+        case 24:
+          _context2.next = 6;
+          break;
+        case 26:
+          _context2.next = 31;
+          break;
+        case 28:
+          _context2.prev = 28;
+          _context2.t0 = _context2["catch"](4);
+          _iterator3.e(_context2.t0);
+        case 31:
+          _context2.prev = 31;
+          _iterator3.f();
+          return _context2.finish(31);
+        case 34:
+          console.log();
+          return _context2.abrupt("return", packagesToRun);
+        case 36:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[4, 28, 31, 34]]);
+  }));
+  return _buildPackages.apply(this, arguments);
+}
+function loadTestsList(_x7) {
+  return _loadTestsList.apply(this, arguments);
+}
+function _loadTestsList() {
+  _loadTestsList = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee4(packages) {
+    var core,
+      packageTestsData,
+      testsList,
+      _iterator4,
+      _step4,
+      testPackage,
+      key,
+      _iterator5,
+      _step5,
+      testValue,
+      _args4 = arguments;
+    return _regenerator["default"].wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          core = _args4.length > 1 && _args4[1] !== undefined ? _args4[1] : false;
+          _context4.next = 3;
+          return testUtils.timeout( /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
+            var params, out, browser, page, r;
+            return _regenerator["default"].wrap(function _callee3$(_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  params = Object.assign({}, testUtils.defaultLaunchParameters); // params['headless'] = false;
+                  _context3.next = 3;
+                  return testUtils.getBrowserPage(_puppeteer["default"], params);
+                case 3:
+                  out = _context3.sent;
+                  browser = out.browser;
+                  page = out.page;
+                  _context3.next = 8;
+                  return page.evaluate(function (packages, coreTests) {
+                    return new Promise(function (resolve, reject) {
+                      var promises = [];
+                      try {
+                        packages.map(function (packageName) {
+                          var _DG$Func$find$;
+                          var p = (_DG$Func$find$ = window.DG.Func.find({
+                            "package": packageName,
+                            name: 'test'
+                          })[0]) === null || _DG$Func$find$ === void 0 ? void 0 : _DG$Func$find$["package"];
+                          if (p) {
+                            try {
+                              promises.push(p.getTests(coreTests)["catch"](function (e) {
+                                console.error('something else went wrong with collecting package tests');
+                                console.error(e === null || e === void 0 ? void 0 : e.message);
+                              }).then(function (ts) {
+                                return {
+                                  packageName: packageName,
+                                  tests: ts
+                                };
+                              }));
+                            } catch (e) {
+                              console.error('something went wrong while adding test collection promise');
+                              console.error(e.message);
+                            }
+                          }
+                        });
+                      } catch (err) {
+                        console.error("Error during evaluation in browser context:", err);
+                        reject();
+                      }
+                      Promise.all(promises).then(function (results) {
+                        resolve(results);
+                      })["catch"](function (e) {
+                        var stack = window.DG.Logger.translateStackTrace(e.stack).then(function () {
+                          resolve({
+                            failReport: "".concat(e.message, "\n").concat(stack)
+                          });
+                        });
+                      });
+                    });
+                  }, packages, core);
+                case 8:
+                  r = _context3.sent;
+                  if (!(browser != null)) {
+                    _context3.next = 12;
+                    break;
+                  }
+                  _context3.next = 12;
+                  return browser.close();
+                case 12:
+                  return _context3.abrupt("return", r);
+                case 13:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          })), testCollectionTimeout);
+        case 3:
+          packageTestsData = _context4.sent;
+          testsList = [];
+          _iterator4 = _createForOfIteratorHelper(packageTestsData);
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              testPackage = _step4.value;
+              for (key in testPackage.tests) {
+                if (testPackage.tests.hasOwnProperty(key)) {
+                  _iterator5 = _createForOfIteratorHelper(testPackage.tests[key].tests);
+                  try {
+                    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                      testValue = _step5.value;
+                      testValue.packageName = testPackage.packageName;
+                      testsList.push(testValue);
+                    }
+                  } catch (err) {
+                    _iterator5.e(err);
+                  } finally {
+                    _iterator5.f();
+                  }
+                }
+              }
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+          return _context4.abrupt("return", testsList);
+        case 8:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _loadTestsList.apply(this, arguments);
+}
+function filterTests(_x8, _x9) {
+  return _filterTests.apply(this, arguments);
+}
+function _filterTests() {
+  _filterTests = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee5(tests, tags) {
+    var stressTest,
+      benchmark,
+      filteredTests,
+      stressTestValue,
+      benchmarkValue,
+      _iterator6,
+      _step6,
+      _loop,
+      _ret,
+      _args6 = arguments;
+    return _regenerator["default"].wrap(function _callee5$(_context6) {
+      while (1) switch (_context6.prev = _context6.next) {
+        case 0:
+          stressTest = _args6.length > 2 && _args6[2] !== undefined ? _args6[2] : false;
+          benchmark = _args6.length > 3 && _args6[3] !== undefined ? _args6[3] : false;
+          filteredTests = [];
+          stressTestValue = tags.includes("stress-test") || stressTest;
+          benchmarkValue = benchmark;
+          tags = tags.filter(function (tag) {
+            return tag !== "stress-test" && tag != "";
+          });
+          _iterator6 = _createForOfIteratorHelper(tests);
+          _context6.prev = 7;
+          _loop = /*#__PURE__*/_regenerator["default"].mark(function _loop() {
+            var _test$options, _test$options2, _test$options3, _tags;
+            var test, hasMatchingTags;
+            return _regenerator["default"].wrap(function _loop$(_context5) {
+              while (1) switch (_context5.prev = _context5.next) {
+                case 0:
+                  test = _step6.value;
+                  if (!(benchmarkValue && ((_test$options = test.options) === null || _test$options === void 0 ? void 0 : _test$options.benchmark) !== true)) {
+                    _context5.next = 3;
+                    break;
+                  }
+                  return _context5.abrupt("return", 0);
+                case 3:
+                  if (!(stressTestValue && ((_test$options2 = test.options) === null || _test$options2 === void 0 ? void 0 : _test$options2.stressTest) !== true && !((_test$options3 = test.options) !== null && _test$options3 !== void 0 && (_test$options3 = _test$options3.tags) !== null && _test$options3 !== void 0 && _test$options3.includes("stressTest")))) {
+                    _context5.next = 5;
+                    break;
+                  }
+                  return _context5.abrupt("return", 0);
+                case 5:
+                  hasMatchingTags = tags.some(function (tag) {
+                    var _test$options4;
+                    return (_test$options4 = test.options) === null || _test$options4 === void 0 || (_test$options4 = _test$options4.tags) === null || _test$options4 === void 0 ? void 0 : _test$options4.includes(tag);
+                  });
+                  if (hasMatchingTags || ((_tags = tags) === null || _tags === void 0 ? void 0 : _tags.length) === 0) filteredTests.push(test);
+                case 7:
+                case "end":
+                  return _context5.stop();
+              }
+            }, _loop);
+          });
+          _iterator6.s();
+        case 10:
+          if ((_step6 = _iterator6.n()).done) {
+            _context6.next = 17;
+            break;
+          }
+          return _context6.delegateYield(_loop(), "t0", 12);
+        case 12:
+          _ret = _context6.t0;
+          if (!(_ret === 0)) {
+            _context6.next = 15;
+            break;
+          }
+          return _context6.abrupt("continue", 15);
+        case 15:
+          _context6.next = 10;
+          break;
+        case 17:
+          _context6.next = 22;
+          break;
+        case 19:
+          _context6.prev = 19;
+          _context6.t1 = _context6["catch"](7);
+          _iterator6.e(_context6.t1);
+        case 22:
+          _context6.prev = 22;
+          _iterator6.f();
+          return _context6.finish(22);
+        case 25:
+          return _context6.abrupt("return", filteredTests);
+        case 26:
+        case "end":
+          return _context6.stop();
+      }
+    }, _callee5, null, [[7, 19, 22, 25]]);
+  }));
+  return _filterTests.apply(this, arguments);
+}
+function setWorkersOrder(_x10) {
+  return _setWorkersOrder.apply(this, arguments);
+}
+function _setWorkersOrder() {
+  _setWorkersOrder = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee6(tests) {
+    var invocationOrder,
+      countOfWorkers,
+      testRepeats,
+      resultOrder,
+      orderingFunction,
+      _args7 = arguments;
+    return _regenerator["default"].wrap(function _callee6$(_context7) {
+      while (1) switch (_context7.prev = _context7.next) {
+        case 0:
+          invocationOrder = _args7.length > 1 && _args7[1] !== undefined ? _args7[1] : 0;
+          countOfWorkers = _args7.length > 2 && _args7[2] !== undefined ? _args7[2] : 1;
+          testRepeats = _args7.length > 3 && _args7[3] !== undefined ? _args7[3] : 1;
+          resultOrder = [];
+          orderingFunction = orderingFunctions.get(invocationOrder);
+          if (!(orderingFunction !== undefined)) {
+            _context7.next = 9;
+            break;
+          }
+          resultOrder = orderingFunction(tests, countOfWorkers, testRepeats);
+          _context7.next = 10;
+          break;
+        case 9:
+          throw new Error("Cannot find ordering function");
+        case 10:
+          return _context7.abrupt("return", resultOrder);
+        case 11:
+        case "end":
+          return _context7.stop();
+      }
+    }, _callee6);
+  }));
+  return _setWorkersOrder.apply(this, arguments);
+}
+function runTests(_x11, _x12) {
+  return _runTests.apply(this, arguments);
+}
+function _runTests() {
+  _runTests = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee7(workersOrder, workerOptions) {
+    var workersCommands, _iterator7, _step7, workerOrder, workersPromises, _i, _workersCommands, workerCommands, resultObjects;
+    return _regenerator["default"].wrap(function _callee7$(_context8) {
+      while (1) switch (_context8.prev = _context8.next) {
+        case 0:
+          workersCommands = [];
+          _iterator7 = _createForOfIteratorHelper(workersOrder);
+          try {
+            for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+              workerOrder = _step7.value;
+              workersCommands.push(workerOrder.map(function (testObj) {
+                return {
+                  "package": testObj.packageName,
+                  params: {
+                    category: testObj.category,
+                    test: testObj.name,
+                    options: {
+                      catchUnhandled: workerOptions.catchUnhandled,
+                      report: workerOptions.report
+                    }
+                  }
+                };
+              }));
+            }
+          } catch (err) {
+            _iterator7.e(err);
+          } finally {
+            _iterator7.f();
+          }
+          workersPromises = [];
+          _i = 0, _workersCommands = workersCommands;
+        case 5:
+          if (!(_i < _workersCommands.length)) {
+            _context8.next = 13;
+            break;
+          }
+          workerCommands = _workersCommands[_i];
+          workersPromises.push(runWorker(workerCommands, workerOptions));
+          _context8.next = 10;
+          return workersPromises[workersPromises.length];
+        case 10:
+          _i++;
+          _context8.next = 5;
+          break;
+        case 13:
+          _context8.next = 15;
+          return Promise.all(workersPromises);
+        case 15:
+          resultObjects = _context8.sent;
+          return _context8.abrupt("return", resultObjects);
+        case 17:
+        case "end":
+          return _context8.stop();
+      }
+    }, _callee7);
+  }));
+  return _runTests.apply(this, arguments);
+}
+function runWorker(_x13, _x14) {
+  return _runWorker.apply(this, arguments);
+}
+function _runWorker() {
+  _runWorker = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee9(testExecutionData, workerOptions) {
+    return _regenerator["default"].wrap(function _callee9$(_context10) {
+      while (1) switch (_context10.prev = _context10.next) {
+        case 0:
+          _context10.next = 2;
+          return testUtils.timeout( /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee8() {
+            var params, out, browser, page, recorder, currentWorkerNum, logsDir, recordDir, testingResults;
+            return _regenerator["default"].wrap(function _callee8$(_context9) {
+              while (1) switch (_context9.prev = _context9.next) {
+                case 0:
+                  params = Object.assign({}, testUtils.defaultLaunchParameters);
+                  if (workerOptions.gui) params['headless'] = false;
+                  _context9.next = 4;
+                  return testUtils.getBrowserPage(_puppeteer["default"], params);
+                case 4:
+                  out = _context9.sent;
+                  browser = out.browser;
+                  page = out.page;
+                  recorder = new _puppeteerScreenRecorder.PuppeteerScreenRecorder(page, testUtils.recorderConfig);
+                  currentWorkerNum = workersStarted++;
+                  logsDir = "./test-console-output-".concat(currentWorkerNum, ".log");
+                  recordDir = "./test-record-".concat(currentWorkerNum, ".mp4");
+                  if (!workerOptions.record) {
+                    _context9.next = 20;
+                    break;
+                  }
+                  _context9.next = 14;
+                  return recorder.start(recordDir);
+                case 14:
+                  _context9.next = 16;
+                  return page.exposeFunction("addLogsToFile", addLogsToFile);
+                case 16:
+                  _fs["default"].writeFileSync(logsDir, "");
+                  page.on('console', function (msg) {
+                    addLogsToFile(logsDir, "CONSOLE LOG ENTRY: ".concat(msg.text(), "\n"));
+                  });
+                  page.on('pageerror', function (error) {
+                    addLogsToFile(logsDir, "CONSOLE LOG ERROR: ".concat(error.message, "\n"));
+                  });
+                  page.on('response', function (response) {
+                    addLogsToFile(logsDir, "CONSOLE LOG REQUEST: ".concat(response.status(), ", ").concat(response.url(), "\n"));
+                  });
+                case 20:
+                  _context9.next = 22;
+                  return page.evaluate(function (testData, options) {
+                    if (options.benchmark) window.DG.Test.isInBenchmark = true;
+                    return new Promise(function (resolve, reject) {
+                      window.DG.Utils.executeTests(testData).then(function (results) {
+                        resolve(results);
+                      })["catch"](function (e) {
+                        resolve({
+                          failed: true,
+                          verbosePassed: "",
+                          verboseSkipped: "",
+                          verboseFailed: "Tests execution failed",
+                          passedAmount: 0,
+                          skippedAmount: 0,
+                          failedAmount: 1
+                        });
+                      });
+                    });
+                  }, testExecutionData, workerOptions);
+                case 22:
+                  testingResults = _context9.sent;
+                  if (!workerOptions.record) {
+                    _context9.next = 26;
+                    break;
+                  }
+                  _context9.next = 26;
+                  return recorder.stop();
+                case 26:
+                  if (!(browser != null)) {
+                    _context9.next = 29;
+                    break;
+                  }
+                  _context9.next = 29;
+                  return browser.close();
+                case 29:
+                  return _context9.abrupt("return", testingResults);
+                case 30:
+                case "end":
+                  return _context9.stop();
+              }
+            }, _callee8);
+          })), testInvocationTimeout);
+        case 2:
+          return _context10.abrupt("return", _context10.sent);
+        case 3:
+        case "end":
+          return _context10.stop();
+      }
+    }, _callee9);
+  }));
+  return _runWorker.apply(this, arguments);
+}
+function addLogsToFile(filePath, stringToSave) {
+  _fs["default"].appendFileSync(filePath, "".concat(stringToSave));
+}
+function printWorkersResult(workerResult) {
+  var verbose = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  if (verbose) {
+    if (workerResult.passedAmount > 0 && workerResult.verbosePassed.length > 0) {
+      console.log("Passed: ");
+      console.log(workerResult.verbosePassed);
+    }
+    if (workerResult.skippedAmount > 0 && workerResult.verboseSkipped.length > 0) {
+      console.log("Skipped: ");
+      console.log(workerResult.verboseSkipped);
+    }
+  }
+  if (workerResult.failedAmount > 0 && workerResult.verboseFailed.length > 0) {
+    console.log("Failed: ");
+    console.log(workerResult.verboseFailed);
+  }
+  console.log("Passed amount:  " + workerResult.passedAmount);
+  console.log("Skipped amount: " + workerResult.skippedAmount);
+  console.log("Failed amount:  " + workerResult.failedAmount);
+  if (workerResult.failed) {
+    color.fail('Tests failed.');
+  } else {
+    color.success('Tests passed.');
+  }
+}

package/bin/grok.js

@@ -14,6 +14,7 @@ const commands = {
   link: require('./commands/link').link,
   publish: require('./commands/publish').publish,
   test: require('./commands/test').test,
+  testall: require('./commands/test-all').testAll,
 };
 
 const command = argv['_'][0];

package/bin/utils/order-functions.js

@@ -0,0 +1,158 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.setAlphabeticalOrder = setAlphabeticalOrder;
+exports.setPackageAlphabeticalOrder = setPackageAlphabeticalOrder;
+exports.setPackageRandomOrder = setPackageRandomOrder;
+exports.setRandomOrder = setRandomOrder;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function setRandomOrder(tests, workersAmount, testRepeats) {
+  if (workersAmount > tests.length) workersAmount = tests.length;
+  var repeatedTests = repeatTests(tests, testRepeats);
+  var orderedTests = shuffle(repeatedTests);
+  return splitArray(orderedTests, workersAmount);
+}
+function setPackageRandomOrder(tests, workersAmount, testRepeats) {
+  var packages = splitTestsByPackages(tests);
+  if (workersAmount > packages.size) workersAmount = packages.size;
+  var _iterator = _createForOfIteratorHelper(packages.keys()),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var packageName = _step.value;
+      packages.set(packageName, repeatTests(packages.get(packageName), testRepeats));
+      packages.set(packageName, shuffle(packages.get(packageName)));
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var splittedPackagesArray = splitArray((0, _toConsumableArray2["default"])(packages.values()), workersAmount);
+  var splittedTestsArray = [];
+  for (var _i = 0, _splittedPackagesArra = splittedPackagesArray; _i < _splittedPackagesArra.length; _i++) {
+    var _splitArray = _splittedPackagesArra[_i];
+    var testsArray = [];
+    var _iterator2 = _createForOfIteratorHelper(_splitArray),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var packageTests = _step2.value;
+        testsArray = testsArray.concat(packageTests);
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    splittedTestsArray.push(testsArray);
+  }
+  return splittedTestsArray;
+}
+function setAlphabeticalOrder(tests, workersAmount, testRepeats) {
+  if (workersAmount > tests.length) workersAmount = tests.length;
+  var repeatedTests = repeatTests(tests, testRepeats);
+  var orderedTests = repeatedTests.sort(function (test1, test2) {
+    return "".concat(test1.category, ": ").concat(test1.name, "s").localeCompare("".concat(test2.category, ": ").concat(test2.name, "s"));
+  });
+  return splitArray(orderedTests, workersAmount);
+}
+function setPackageAlphabeticalOrder(tests, workersAmount, testRepeats) {
+  var packages = splitTestsByPackages(tests);
+  if (workersAmount > packages.size) workersAmount = packages.size;
+  var _iterator3 = _createForOfIteratorHelper(packages.keys()),
+    _step3;
+  try {
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      var packageName = _step3.value;
+      packages.set(packageName, repeatTests(packages.get(packageName), testRepeats));
+      packages.set(packageName, packages.get(packageName).sort(alphabeticalSortFunction));
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+  var splittedPackagesArray = splitArray((0, _toConsumableArray2["default"])(packages.values()), workersAmount);
+  var splittedTestsArray = [];
+  for (var _i2 = 0, _splittedPackagesArra2 = splittedPackagesArray; _i2 < _splittedPackagesArra2.length; _i2++) {
+    var _splitArray2 = _splittedPackagesArra2[_i2];
+    var testsArray = [];
+    var _iterator4 = _createForOfIteratorHelper(_splitArray2),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var packageTests = _step4.value;
+        testsArray = testsArray.concat(packageTests);
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+    splittedTestsArray.push(testsArray);
+  }
+  return splittedTestsArray;
+}
+function alphabeticalSortFunction(test1, test2) {
+  return "".concat(test1.category, ": ").concat(test1.name, "s").localeCompare("".concat(test2.category, ": ").concat(test2.name, "s"));
+}
+function splitTestsByPackages(tests) {
+  var resultMap = new Map();
+  var _iterator5 = _createForOfIteratorHelper(tests),
+    _step5;
+  try {
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      var test = _step5.value;
+      if (resultMap.has(test.packageName)) resultMap.get(test.packageName).push(test);else resultMap.set(test.packageName, [test]);
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+  return resultMap;
+}
+function repeatTests(tests, testRepeats) {
+  var repeatedTests = [];
+  var _iterator6 = _createForOfIteratorHelper(tests),
+    _step6;
+  try {
+    for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+      var test = _step6.value;
+      for (var i = 0; i < testRepeats; i++) {
+        repeatedTests.push(_objectSpread({}, test));
+      }
+    }
+  } catch (err) {
+    _iterator6.e(err);
+  } finally {
+    _iterator6.f();
+  }
+  return repeatedTests;
+}
+function shuffle(array) {
+  var newArr = array.slice();
+  newArr.sort(function () {
+    return Math.random() - 0.5;
+  });
+  return newArr;
+}
+;
+function splitArray(arr, countOfParts) {
+  var result = [];
+  var partSize = Math.ceil(arr.length / countOfParts);
+  for (var i = 0; i < arr.length; i += partSize) {
+    result.push(arr.slice(i, i + partSize));
+  }
+  return result;
+}

package/bin/utils/utils.js

@@ -22,7 +22,9 @@ exports.kebabToCamelCase = kebabToCamelCase;
 exports.mapURL = mapURL;
 exports.queryWrapperTemplate = exports.queryExtension = exports.propertyTypes = exports.paramRegex = exports.namespaceTemplate = exports.nameRegex = exports.nameAnnRegex = void 0;
 exports.removeScope = removeScope;
-exports.scriptWrapperTemplate = exports.scriptLangExtMap = exports.scriptExtensions = exports.replacers = void 0;
+exports.replacers = void 0;
+exports.runScript = runScript;
+exports.scriptWrapperTemplate = exports.scriptLangExtMap = exports.scriptExtensions = void 0;
 exports.spaceToCamelCase = spaceToCamelCase;
 exports.wordsToCamelCase = wordsToCamelCase;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
@@ -32,9 +34,13 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _fs = _interopRequireDefault(require("fs"));
 var _path = _interopRequireDefault(require("path"));
+var _child_process = require("child_process");
+var _util = require("util");
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+var execAsync = (0, _util.promisify)(_child_process.exec);
+
 /* Waits [ms] milliseconds */
 function delay(_x) {
   return _delay.apply(this, arguments);
@@ -280,4 +286,48 @@ function getScriptInputs(script) {
 var dgImports = exports.dgImports = "import * as grok from 'datagrok-api/grok';\nimport * as DG from 'datagrok-api/dg';\n\n";
 var scriptWrapperTemplate = exports.scriptWrapperTemplate = "export async function #{FUNC_NAME_LOWERCASE}(#{TYPED_PARAMS}): Promise<#{OUTPUT_TYPE}> {\n  return await grok.functions.call('#{PACKAGE_NAMESPACE}:#{FUNC_NAME}', #{PARAMS_OBJECT});\n}";
 var queryWrapperTemplate = exports.queryWrapperTemplate = "export async function #{FUNC_NAME_LOWERCASE}(#{TYPED_PARAMS}): Promise<#{OUTPUT_TYPE}> {\n  return await grok.data.query('#{PACKAGE_NAMESPACE}:#{FUNC_NAME}', #{PARAMS_OBJECT});\n}";
-var namespaceTemplate = exports.namespaceTemplate = "export namespace #{PACKAGE_NAMESPACE} {\n#{NAME}\n}";
+var namespaceTemplate = exports.namespaceTemplate = "export namespace #{PACKAGE_NAMESPACE} {\n#{NAME}\n}";
+function runScript(_x2, _x3) {
+  return _runScript.apply(this, arguments);
+}
+function _runScript() {
+  _runScript = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(script, path) {
+    var verbose,
+      _yield$execAsync,
+      stdout,
+      stderr,
+      _args2 = arguments;
+    return _regenerator["default"].wrap(function _callee2$(_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          verbose = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : false;
+          _context2.prev = 1;
+          _context2.next = 4;
+          return execAsync(script, {
+            cwd: path
+          });
+        case 4:
+          _yield$execAsync = _context2.sent;
+          stdout = _yield$execAsync.stdout;
+          stderr = _yield$execAsync.stderr;
+          if (stderr && verbose) {
+            console.error("Warning/Error: ".concat(stderr));
+          }
+          if (stdout && verbose) {
+            console.log("Output: ".concat(stdout));
+          }
+          _context2.next = 15;
+          break;
+        case 11:
+          _context2.prev = 11;
+          _context2.t0 = _context2["catch"](1);
+          console.error("Execution failed: ".concat(_context2.t0.message));
+          throw new Error("Cant run script");
+        case 15:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2, null, [[1, 11]]);
+  }));
+  return _runScript.apply(this, arguments);
+}

package/package-template/src/package-test.ts

@@ -1,6 +1,6 @@
 import * as DG from "datagrok-api/dg";
 import * as grok from 'datagrok-api/grok';
-import { runTests, tests, TestContext } from '@datagrok-libraries/utils/src/test';
+import { runTests, tests, TestContext , initAutoTests as initTests } from '@datagrok-libraries/utils/src/test';
 
 export let _package = new DG.Package();
 export { tests };
@@ -13,4 +13,9 @@ export { tests };
 export async function test(category: string, test: string, testContext: TestContext): Promise<DG.DataFrame> {
   const data = await runTests({ category, test, testContext });
   return DG.DataFrame.fromObjects(data)!;
-}
+}
+
+//name: initAutoTests
+export async function initAutoTests() {
+  await initTests(_package, _package.getModule('package-test.js'));
+}

package/package.json

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