@iobroker/testing 5.0.0 → 5.0.3

package/build/tests/integration/lib/dbConnection.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -32,7 +42,7 @@ const events_1 = __importDefault(require("events"));
 const fs_extra_1 = require("fs-extra");
 const path = __importStar(require("path"));
 const tools_1 = require("./tools");
-const debug = (0, debug_1.default)("testing:integration:DBConnection");
+const debug = (0, debug_1.default)('testing:integration:DBConnection');
 /** The DB connection capsules access to the states and objects DB */
 class DBConnection extends events_1.default {
     /**
@@ -45,45 +55,45 @@ class DBConnection extends events_1.default {
         this.testDir = testDir;
         this.logger = logger;
         this._isRunning = false;
-        this.getObject = async (id) => {
+        this.getObject = id => {
             if (!this._objectsClient) {
-                throw new Error("Objects DB is not running");
+                throw new Error('Objects DB is not running');
             }
             return this._objectsClient.getObjectAsync(id);
         };
-        this.setObject = async (...args) => {
+        this.setObject = (...args) => {
             if (!this._objectsClient) {
-                throw new Error("Objects DB is not running");
+                throw new Error('Objects DB is not running');
             }
             return this._objectsClient.setObjectAsync(...args);
         };
-        this.delObject = async (...args) => {
+        this.delObject = (...args) => {
             if (!this._objectsClient) {
-                throw new Error("Objects DB is not running");
+                throw new Error('Objects DB is not running');
             }
             return this._objectsClient.delObjectAsync(...args);
         };
-        this.getState = async (id) => {
+        this.getState = (id) => {
             if (!this._statesClient) {
-                throw new Error("States DB is not running");
+                throw new Error('States DB is not running');
             }
             return this._statesClient.getStateAsync(id);
         };
-        this.setState = (async (...args) => {
+        this.setState = ((...args) => {
             if (!this._statesClient) {
-                throw new Error("States DB is not running");
+                throw new Error('States DB is not running');
             }
             return this._statesClient.setStateAsync(...args);
         });
-        this.delState = async (...args) => {
+        this.delState = (...args) => {
             if (!this._statesClient) {
-                throw new Error("States DB is not running");
+                throw new Error('States DB is not running');
             }
             return this._statesClient.delStateAsync(...args);
         };
-        this.getObjectViewAsync = async (...args) => {
+        this.getObjectViewAsync = (...args) => {
             if (!this._objectsClient) {
-                throw new Error("Objects DB is not running");
+                throw new Error('Objects DB is not running');
             }
             return this._objectsClient.getObjectViewAsync(...args);
         };
@@ -102,36 +112,38 @@ class DBConnection extends events_1.default {
         return this.getSystemConfig().objects.type;
     }
     get objectsPath() {
-        return path.join(this.testDataDir, this.objectsType === "file" ? "objects.json" : "objects.jsonl");
+        return path.join(this.testDataDir, this.objectsType === 'file' ? 'objects.json' : 'objects.jsonl');
     }
     get statesType() {
         return this.getSystemConfig().states.type;
     }
     get statesPath() {
-        return path.join(this.testDataDir, this.statesType === "file" ? "states.json" : "states.jsonl");
+        return path.join(this.testDataDir, this.statesType === 'file' ? 'states.json' : 'states.jsonl');
     }
     getSystemConfig() {
         const systemFilename = path.join(this.testDataDir, `${this.appName}.json`);
         return (0, fs_extra_1.readJSONSync)(systemFilename);
     }
     async backup() {
-        debug("Creating DB backup...");
+        debug('Creating DB backup...');
         const wasRunning = this._isRunning;
         await this.stop();
         const objects = await (0, fs_extra_1.readFile)(this.objectsPath);
         const states = await (0, fs_extra_1.readFile)(this.statesPath);
-        if (wasRunning)
+        if (wasRunning) {
             await this.start();
+        }
         return { objects, states };
     }
     async restore(objects, states) {
-        debug("Restoring DB backup...");
+        debug('Restoring DB backup...');
         const wasRunning = this._isRunning;
         await this.stop();
         await (0, fs_extra_1.writeFile)(this.objectsPath, objects);
         await (0, fs_extra_1.writeFile)(this.statesPath, states);
-        if (wasRunning)
+        if (wasRunning) {
             await this.start();
+        }
     }
     setSystemConfig(systemConfig) {
         const systemFilename = path.join(this.testDataDir, `${this.appName}.json`);
@@ -142,21 +154,21 @@ class DBConnection extends events_1.default {
     }
     async start() {
         if (this._isRunning) {
-            debug("At least one DB instance is already running, not starting again...");
+            debug('At least one DB instance is already running, not starting again...');
             return;
         }
-        debug("starting DB instances...");
+        debug('starting DB instances...');
         await this.createObjectsDB();
         await this.createStatesDB();
         this._isRunning = true;
-        debug("DB instances started");
+        debug('DB instances started');
     }
     async stop() {
         if (!this._isRunning) {
-            debug("No DB instance is running, nothing to stop...");
+            debug('No DB instance is running, nothing to stop...');
             return;
         }
-        debug("Stopping DB instances...");
+        debug('Stopping DB instances...');
         // Stop clients before servers
         await this._objectsClient?.destroy();
         await this._objectsServer?.destroy();
@@ -167,36 +179,32 @@ class DBConnection extends events_1.default {
         this._statesClient = null;
         this._statesServer = null;
         this._isRunning = false;
-        debug("DB instances stopped");
+        debug('DB instances stopped');
     }
     /** Creates the objects DB and sets up listeners for it */
     async createObjectsDB() {
-        debug("creating objects DB");
+        debug('creating objects DB');
         const objectsType = this.objectsType;
         debug(`  => objects DB type: ${objectsType}`);
         const settings = {
             connection: {
                 type: objectsType,
-                host: "127.0.0.1",
+                host: '127.0.0.1',
                 port: 19001,
-                user: "",
-                pass: "",
+                user: '',
+                pass: '',
                 noFileCache: false,
                 connectTimeout: 2000,
             },
             logger: this.logger,
         };
         const objectsDbPath = require.resolve(`@iobroker/db-objects-${objectsType}`, {
-            paths: [
-                path.join(this.testDir, "node_modules"),
-                path.join(this.testControllerDir, "node_modules"),
-            ],
+            paths: [path.join(this.testDir, 'node_modules'), path.join(this.testControllerDir, 'node_modules')],
         });
         debug(`  => objects DB lib found at ${objectsDbPath}`);
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
         const { Server, Client } = require(objectsDbPath);
         // First create the server
-        await new Promise((resolve) => {
+        await new Promise(resolve => {
             this._objectsServer = new Server({
                 ...settings,
                 connected: () => {
@@ -205,17 +213,17 @@ class DBConnection extends events_1.default {
             });
         });
         // Then the client
-        await new Promise((resolve) => {
+        await new Promise(resolve => {
             this._objectsClient = new Client({
                 ...settings,
                 connected: () => {
-                    this._objectsClient.subscribe("*");
+                    this._objectsClient.subscribe('*');
                     resolve();
                 },
-                change: this.emit.bind(this, "objectChange"),
+                change: this.emit.bind(this, 'objectChange'),
             });
         });
-        debug("  => done!");
+        debug('  => done!');
     }
     /** Creates the states DB and sets up listeners for it */
     async createStatesDB() {
@@ -225,7 +233,7 @@ class DBConnection extends events_1.default {
         const settings = {
             connection: {
                 type: statesType,
-                host: "127.0.0.1",
+                host: '127.0.0.1',
                 port: 19000,
                 options: {
                     auth_pass: null,
@@ -235,16 +243,12 @@ class DBConnection extends events_1.default {
             logger: this.logger,
         };
         const statesDbPath = require.resolve(`@iobroker/db-states-${statesType}`, {
-            paths: [
-                path.join(this.testDir, "node_modules"),
-                path.join(this.testControllerDir, "node_modules"),
-            ],
+            paths: [path.join(this.testDir, 'node_modules'), path.join(this.testControllerDir, 'node_modules')],
         });
         debug(`  => states DB lib found at ${statesDbPath}`);
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
         const { Server, Client } = require(statesDbPath);
         // First create the server
-        await new Promise((resolve) => {
+        await new Promise(resolve => {
             this._statesServer = new Server({
                 ...settings,
                 connected: () => {
@@ -253,43 +257,41 @@ class DBConnection extends events_1.default {
             });
         });
         // Then the client
-        await new Promise((resolve) => {
+        await new Promise(resolve => {
             this._statesClient = new Client({
                 ...settings,
                 connected: () => {
-                    this._statesClient.subscribe("*");
+                    this._statesClient.subscribe('*');
                     resolve();
                 },
-                change: this.emit.bind(this, "stateChange"),
+                change: this.emit.bind(this, 'stateChange'),
             });
         });
-        debug("  => done!");
+        debug('  => done!');
     }
     subscribeMessage(id) {
         if (!this._statesClient) {
-            throw new Error("States DB is not running");
+            throw new Error('States DB is not running');
         }
         return this._statesClient.subscribeMessage(id);
     }
     pushMessage(instanceId, msg, callback) {
         if (!this._statesClient) {
-            throw new Error("States DB is not running");
+            throw new Error('States DB is not running');
         }
         this._statesClient.pushMessage(instanceId, msg, callback);
     }
-    async getStateIDs(pattern = "*") {
+    getStateIDs(pattern = '*') {
         if (!this._statesClient) {
-            throw new Error("States DB is not running");
+            throw new Error('States DB is not running');
         }
-        return (this._statesClient.getKeysAsync?.(pattern) ||
-            this._statesClient.getKeys?.(pattern));
+        return this._statesClient.getKeysAsync?.(pattern) || this._statesClient.getKeys?.(pattern);
     }
-    async getObjectIDs(pattern = "*") {
+    getObjectIDs(pattern = '*') {
         if (!this._objectsClient) {
-            throw new Error("Objects DB is not running");
+            throw new Error('Objects DB is not running');
         }
-        return (this._objectsClient.getKeysAsync?.(pattern) ||
-            this._objectsClient.getKeys?.(pattern));
+        return this._objectsClient.getKeysAsync?.(pattern) || this._objectsClient.getKeys?.(pattern);
     }
 }
 exports.DBConnection = DBConnection;

package/build/tests/integration/lib/harness.d.ts

@@ -1,10 +1,10 @@
-import { ChildProcess } from "child_process";
-import { EventEmitter } from "events";
-import type { DBConnection } from "./dbConnection";
+import { type ChildProcess } from 'child_process';
+import { EventEmitter } from 'events';
+import type { DBConnection } from './dbConnection';
 export interface TestHarness {
-    on(event: "objectChange", handler: ioBroker.ObjectChangeHandler): this;
-    on(event: "stateChange", handler: ioBroker.StateChangeHandler): this;
-    on(event: "failed", handler: (codeOrSignal: number | string) => void): this;
+    on(event: 'objectChange', handler: ioBroker.ObjectChangeHandler): this;
+    on(event: 'stateChange', handler: ioBroker.StateChangeHandler): this;
+    on(event: 'failed', handler: (codeOrSignal: number | string) => void): this;
 }
 /**
  * The test harness capsules the execution of the JS-Controller and the adapter instance and monitors their status.
@@ -41,11 +41,13 @@ export declare class TestHarness extends EventEmitter {
     stopController(): Promise<void>;
     /**
      * Starts the adapter in a separate process and monitors its status
+     *
      * @param env Additional environment variables to set
      */
     startAdapter(env?: NodeJS.ProcessEnv): Promise<void>;
     /**
      * Starts the adapter in a separate process and resolves after it has started
+     *
      * @param waitForConnection By default, the test will wait for the adapter's `alive` state to become true. Set this to `true` to wait for the `info.connection` state instead.
      * @param env Additional environment variables to set
      */
@@ -60,7 +62,7 @@ export declare class TestHarness extends EventEmitter {
      * Updates the adapter config. The changes can be a subset of the target object
      */
     changeAdapterConfig(adapterName: string, changes: Record<string, any>): Promise<void>;
-    getAdapterExecutionMode(): ioBroker.AdapterCommon["mode"];
+    getAdapterExecutionMode(): ioBroker.AdapterCommon['mode'];
     /** Enables the sendTo method */
     enableSendTo(): Promise<void>;
     private sendToID;

package/build/tests/integration/lib/harness.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -35,9 +45,9 @@ const events_1 = require("events");
 const path = __importStar(require("path"));
 const adapterTools_1 = require("../../../lib/adapterTools");
 const tools_1 = require("./tools");
-const debug = (0, debug_1.default)("testing:integration:TestHarness");
+const debug = (0, debug_1.default)('testing:integration:TestHarness');
 const isWindows = /^win/.test(process.platform);
-const fromAdapterID = "system.adapter.test.0";
+const fromAdapterID = 'system.adapter.test.0';
 /**
  * The test harness capsules the execution of the JS-Controller and the adapter instance and monitors their status.
  * Use it in every test to start a fresh adapter instance
@@ -53,7 +63,7 @@ class TestHarness extends events_1.EventEmitter {
         this.testDir = testDir;
         this.dbConnection = dbConnection;
         this.sendToID = 1;
-        debug("Creating instance");
+        debug('Creating instance');
         this.adapterName = (0, adapterTools_1.getAdapterName)(this.adapterDir);
         this.appName = (0, adapterTools_1.getAppName)(adapterDir);
         this.testControllerDir = (0, tools_1.getTestControllerDir)(this.appName, testDir);
@@ -63,24 +73,24 @@ class TestHarness extends events_1.EventEmitter {
         debug(`    adapter:    ${this.testAdapterDir}`);
         debug(`  appName:           ${this.appName}`);
         debug(`  adapterName:       ${this.adapterName}`);
-        dbConnection.on("objectChange", (id, obj) => {
-            this.emit("objectChange", id, obj);
+        dbConnection.on('objectChange', (id, obj) => {
+            this.emit('objectChange', id, obj);
         });
-        dbConnection.on("stateChange", (id, state) => {
-            this.emit("stateChange", id, state);
+        dbConnection.on('stateChange', (id, state) => {
+            this.emit('stateChange', id, state);
         });
     }
     /** Gives direct access to the Objects DB */
     get objects() {
         if (!this.dbConnection.objectsClient) {
-            throw new Error("Objects DB is not running");
+            throw new Error('Objects DB is not running');
         }
         return this.dbConnection.objectsClient;
     }
     /** Gives direct access to the States DB */
     get states() {
         if (!this.dbConnection.statesClient) {
-            throw new Error("States DB is not running");
+            throw new Error('States DB is not running');
         }
         return this.dbConnection.statesClient;
     }
@@ -104,59 +114,67 @@ class TestHarness extends events_1.EventEmitter {
     }
     /** Stops the controller instance (and the adapter if it is running) */
     async stopController() {
-        if (!this.isControllerRunning())
+        if (!this.isControllerRunning()) {
             return;
+        }
         if (!this.didAdapterStop()) {
-            debug("Stopping adapter instance...");
+            debug('Stopping adapter instance...');
             // Give the adapter time to stop (as long as configured in the io-package.json)
             let stopTimeout;
             try {
-                stopTimeout = (await this.dbConnection.getObject(`system.adapter.${this.adapterName}.0`)).common.stopTimeout;
+                stopTimeout = (await this.dbConnection.getObject(`system.adapter.${this.adapterName}.0`))
+                    .common.stopTimeout;
                 stopTimeout += 1000;
             }
-            catch { }
-            stopTimeout || (stopTimeout = 5000); // default 5s
+            catch {
+                // ignore
+            }
+            stopTimeout ||= 5000; // default 5s
             debug(`  => giving it ${stopTimeout}ms to terminate`);
             await Promise.race([this.stopAdapter(), (0, async_1.wait)(stopTimeout)]);
             if (this.isAdapterRunning()) {
-                debug("Adapter did not terminate, killing it");
-                this._adapterProcess.kill("SIGKILL");
+                debug('Adapter did not terminate, killing it');
+                this._adapterProcess.kill('SIGKILL');
             }
             else {
-                debug("Adapter terminated");
+                debug('Adapter terminated');
             }
         }
         else {
-            debug("Adapter failed to start - no need to terminate!");
+            debug('Adapter failed to start - no need to terminate!');
         }
         await this.dbConnection.stop();
     }
     /**
      * Starts the adapter in a separate process and monitors its status
+     *
      * @param env Additional environment variables to set
      */
     async startAdapter(env = {}) {
-        if (this.isAdapterRunning())
-            throw new Error("The adapter is already running!");
-        else if (this.didAdapterStop())
-            throw new Error("This test harness has already been used. Please create a new one for each test!");
+        if (this.isAdapterRunning()) {
+            throw new Error('The adapter is already running!');
+        }
+        else if (this.didAdapterStop()) {
+            throw new Error('This test harness has already been used. Please create a new one for each test!');
+        }
         const mainFileAbsolute = await (0, adapterTools_1.locateAdapterMainFile)(this.testAdapterDir);
         const mainFileRelative = path.relative(this.testAdapterDir, mainFileAbsolute);
         const onClose = (code, signal) => {
             this._adapterProcess.removeAllListeners();
             this._adapterExit = code != undefined ? code : signal;
-            this.emit("failed", this._adapterExit);
+            this.emit('failed', this._adapterExit);
         };
-        this._adapterProcess = (0, child_process_1.spawn)(isWindows ? "node.exe" : "node", [mainFileRelative, "--console"], {
+        this._adapterProcess = (0, child_process_1.spawn)(isWindows ? 'node.exe' : 'node', [mainFileRelative, '--console'], {
             cwd: this.testAdapterDir,
-            stdio: ["inherit", "inherit", "inherit"],
+            stdio: ['inherit', 'inherit', 'inherit'],
             env: { ...process.env, ...env },
         })
-            .on("close", onClose)
-            .on("exit", onClose);
+            .on('close', onClose)
+            .on('exit', onClose);
     }
     /**
      * Starts the adapter in a separate process and resolves after it has started
+     *
      * @param waitForConnection By default, the test will wait for the adapter's `alive` state to become true. Set this to `true` to wait for the `info.connection` state instead.
      * @param env Additional environment variables to set
      */
@@ -165,13 +183,13 @@ class TestHarness extends events_1.EventEmitter {
             const waitForStateId = waitForConnection
                 ? `${this.adapterName}.0.info.connection`
                 : `system.adapter.${this.adapterName}.0.alive`;
-            this.on("stateChange", async (id, state) => {
+            void this.on('stateChange', (id, state) => {
                 if (id === waitForStateId && state && state.val === true) {
                     resolve();
                 }
             })
-                .on("failed", (code) => {
-                reject(new Error(`The adapter startup was interrupted unexpectedly with ${typeof code === "number" ? "code" : "signal"} ${code}`));
+                .on('failed', code => {
+                reject(new Error(`The adapter startup was interrupted unexpectedly with ${typeof code === 'number' ? 'code' : 'signal'} ${code}`));
             })
                 .startAdapter(env);
         });
@@ -186,33 +204,34 @@ class TestHarness extends events_1.EventEmitter {
     }
     /** Stops the adapter process */
     stopAdapter() {
-        if (!this.isAdapterRunning())
+        if (!this.isAdapterRunning()) {
             return;
+        }
+        // eslint-disable-next-line no-async-promise-executor
         return new Promise(async (resolve) => {
             const onClose = (code, signal) => {
-                if (!this._adapterProcess)
+                if (!this._adapterProcess) {
                     return;
+                }
                 this._adapterProcess.removeAllListeners();
                 this._adapterExit = code != undefined ? code : signal;
                 this._adapterProcess = undefined;
-                debug("Adapter process terminated:");
+                debug('Adapter process terminated:');
                 debug(`  Code:   ${code}`);
                 debug(`  Signal: ${signal}`);
                 resolve();
             };
-            this._adapterProcess.removeAllListeners()
-                .on("close", onClose)
-                .on("exit", onClose);
+            this._adapterProcess.removeAllListeners().on('close', onClose).on('exit', onClose);
             // Tell adapter to stop
             try {
                 await this.dbConnection.setState(`system.adapter.${this.adapterName}.0.sigKill`, {
                     val: -1,
-                    from: "system.host.testing",
+                    from: 'system.host.testing',
                 });
             }
             catch {
                 // DB connection may be closed already, kill the process
-                this._adapterProcess?.kill("SIGTERM");
+                this._adapterProcess?.kill('SIGTERM');
             }
         });
     }
@@ -233,7 +252,7 @@ class TestHarness extends events_1.EventEmitter {
     /** Enables the sendTo method */
     async enableSendTo() {
         await this.dbConnection.setObject(fromAdapterID, {
-            type: "instance",
+            type: 'instance',
             common: {},
             native: {},
             instanceObjects: [],
@@ -246,10 +265,10 @@ class TestHarness extends events_1.EventEmitter {
         const stateChangedHandler = (id, state) => {
             if (id === `messagebox.${fromAdapterID}`) {
                 callback(state.message);
-                this.removeListener("stateChange", stateChangedHandler);
+                this.removeListener('stateChange', stateChangedHandler);
             }
         };
-        this.addListener("stateChange", stateChangedHandler);
+        this.addListener('stateChange', stateChangedHandler);
         this.dbConnection.pushMessage(`system.adapter.${target}`, {
             command: command,
             message: message,
@@ -260,7 +279,7 @@ class TestHarness extends events_1.EventEmitter {
                 ack: false,
                 time: Date.now(),
             },
-        }, (err, id) => console.log("published message " + id));
+        }, (err, id) => console.log(`published message ${id}`));
     }
 }
 exports.TestHarness = TestHarness;

package/build/tests/integration/lib/logger.js

@@ -10,7 +10,7 @@ var LoglevelOrder;
     LoglevelOrder[LoglevelOrder["silly"] = 4] = "silly";
 })(LoglevelOrder || (LoglevelOrder = {}));
 function createLogger(loglevel) {
-    const loglevelNumeric = LoglevelOrder[loglevel ?? "debug"] ?? LoglevelOrder.debug;
+    const loglevelNumeric = LoglevelOrder[loglevel ?? 'debug'] ?? LoglevelOrder.debug;
     const ignore = () => { };
     return {
         error: loglevelNumeric >= LoglevelOrder.error ? console.error : ignore,