@iobroker/testing 2.5.0 → 2.5.4

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

@@ -18,93 +18,287 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DBConnection = void 0;
+const debug_1 = __importDefault(require("debug"));
+const events_1 = __importDefault(require("events"));
 const fs_extra_1 = require("fs-extra");
 const path = __importStar(require("path"));
 const tools_1 = require("./tools");
-/** The DB connection capsules access to the objects.json and states.json on disk */
-class DBConnection {
+const debug = (0, debug_1.default)("testing:integration:DBConnection");
+/** The logger instance for the objects and states DB */
+const logger = {
+    silly: console.log,
+    debug: console.log,
+    info: console.log,
+    warn: console.warn,
+    error: console.error,
+};
+/** The DB connection capsules access to the states and objects DB */
+class DBConnection extends events_1.default {
     /**
      * @param appName The branded name of "iobroker"
      * @param testDir The directory the integration tests are executed in
      */
     constructor(appName, testDir) {
+        super();
         this.appName = appName;
         this.testDir = testDir;
-        this.testDataDir = tools_1.getTestDataDir(appName, testDir);
-        this.objectsPath = path.join(this.testDataDir, "objects.json");
-        this.statesPath = path.join(this.testDataDir, "states.json");
-    }
-    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-    readObjectsDB() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // debug(`reading objects db...`);
-            // debug(`  dataDir:     ${dataDir}`);
-            // debug(`  objectsPath: ${objectsPath}`);
-            if (yield fs_extra_1.pathExists(this.objectsPath)) {
-                // debug(`  exists:      true`);
-                return fs_extra_1.readJSON(this.objectsPath, { encoding: "utf8" });
+        this._isRunning = false;
+        this.getObject = async (id) => {
+            if (!this._objectsClient) {
+                throw new Error("Objects DB is not running");
+            }
+            return this._objectsClient.getObjectAsync(id);
+        };
+        this.setObject = async (...args) => {
+            if (!this._objectsClient) {
+                throw new Error("Objects DB is not running");
+            }
+            return this._objectsClient.setObjectAsync(...args);
+        };
+        this.delObject = async (...args) => {
+            if (!this._objectsClient) {
+                throw new Error("Objects DB is not running");
+            }
+            return this._objectsClient.delObjectAsync(...args);
+        };
+        this.getState = async (id) => {
+            if (!this._statesClient) {
+                throw new Error("States DB is not running");
+            }
+            return this._statesClient.getStateAsync(id);
+        };
+        this.setState = (async (...args) => {
+            if (!this._statesClient) {
+                throw new Error("States DB is not running");
             }
+            return this._statesClient.setStateAsync(...args);
         });
+        this.delState = async (...args) => {
+            if (!this._statesClient) {
+                throw new Error("States DB is not running");
+            }
+            return this._statesClient.delStateAsync(...args);
+        };
+        this.getObjectViewAsync = async (...args) => {
+            if (!this._objectsClient) {
+                throw new Error("Objects DB is not running");
+            }
+            return this._objectsClient.getObjectViewAsync(...args);
+        };
+        this.testControllerDir = (0, tools_1.getTestControllerDir)(this.appName, testDir);
+        this.testDataDir = (0, tools_1.getTestDataDir)(appName, testDir);
     }
-    writeObjectsDB(objects) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!objects)
-                return;
-            return fs_extra_1.writeJSON(this.objectsPath, objects);
-        });
+    /** The underlying objects client instance that can be used to access the objects DB */
+    get objectsClient() {
+        return this._objectsClient;
     }
-    writeStatesDB(states) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!states)
-                return;
-            return fs_extra_1.writeJSON(this.statesPath, states);
-        });
+    /** The underlying states client instance that can be used to access the states DB */
+    get statesClient() {
+        return this._statesClient;
     }
-    readStatesDB() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // debug(`reading states db...`);
-            // debug(`  dataDir:     ${dataDir}`);
-            // debug(`  statesPath:  ${statesPath}`);
-            if (yield fs_extra_1.pathExists(this.statesPath)) {
-                // debug(`  exists:      true`);
-                return fs_extra_1.readJSON(this.statesPath, { encoding: "utf8" });
-            }
-        });
+    get objectsType() {
+        return this.getSystemConfig().objects.type;
     }
-    /**
-     * Creates a backup of the objects and states DB, so it can be restored after each test
-     * @param appName The branded name of "iobroker"
-     * @param testDir The directory the integration tests are executed in
-     */
-    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-    readDB() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const objects = yield this.readObjectsDB();
-            const states = yield this.readStatesDB();
-            return { objects, states };
+    get objectsPath() {
+        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");
+    }
+    getSystemConfig() {
+        const systemFilename = path.join(this.testDataDir, `${this.appName}.json`);
+        return (0, fs_extra_1.readJSONSync)(systemFilename);
+    }
+    async 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)
+            await this.start();
+        return { objects, states };
+    }
+    async restore(objects, states) {
+        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)
+            await this.start();
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    setSystemConfig(systemConfig) {
+        const systemFilename = path.join(this.testDataDir, `${this.appName}.json`);
+        (0, fs_extra_1.writeJSONSync)(systemFilename, systemConfig, { spaces: 2 });
+    }
+    get isRunning() {
+        return this._isRunning;
+    }
+    async start() {
+        if (this._isRunning) {
+            debug("At least one DB instance is already running, not starting again...");
+            return;
+        }
+        debug("starting DB instances...");
+        await this.createObjectsDB();
+        await this.createStatesDB();
+        this._isRunning = true;
+        debug("DB instances started");
+    }
+    async stop() {
+        var _a, _b, _c, _d;
+        if (!this._isRunning) {
+            debug("No DB instance is running, nothing to stop...");
+            return;
+        }
+        debug("Stopping DB instances...");
+        // Stop clients before servers
+        await ((_a = this._objectsClient) === null || _a === void 0 ? void 0 : _a.destroy());
+        await ((_b = this._objectsServer) === null || _b === void 0 ? void 0 : _b.destroy());
+        await ((_c = this._statesClient) === null || _c === void 0 ? void 0 : _c.destroy());
+        await ((_d = this._statesServer) === null || _d === void 0 ? void 0 : _d.destroy());
+        this._objectsClient = null;
+        this._objectsServer = null;
+        this._statesClient = null;
+        this._statesServer = null;
+        this._isRunning = false;
+        debug("DB instances stopped");
+    }
+    /** Creates the objects DB and sets up listeners for it */
+    async createObjectsDB() {
+        debug("creating objects DB");
+        const objectsType = this.objectsType;
+        debug(`  => objects DB type: ${objectsType}`);
+        const settings = {
+            connection: {
+                type: objectsType,
+                host: "127.0.0.1",
+                port: 19001,
+                user: "",
+                pass: "",
+                noFileCache: false,
+                connectTimeout: 2000,
+            },
+            logger,
+        };
+        const objectsDbPath = require.resolve(`@iobroker/db-objects-${objectsType}`, {
+            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-var-requires
+        const { Server, Client } = require(objectsDbPath);
+        // First create the server
+        await new Promise((resolve) => {
+            this._objectsServer = new Server({
+                ...settings,
+                connected: () => {
+                    resolve();
+                },
+            });
         });
+        // Then the client
+        await new Promise((resolve) => {
+            this._objectsClient = new Client({
+                ...settings,
+                connected: () => {
+                    this._objectsClient.subscribe("*");
+                    resolve();
+                },
+                change: this.emit.bind(this, "objectChange"),
+            });
+        });
+        debug("  => done!");
     }
-    /**
-     * Restores a previous backup of the objects and states DB
-     * @param appName The branded name of "iobroker"
-     * @param testDir The directory the integration tests are executed in
-     */
-    writeDB(objects, states) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.writeObjectsDB(objects);
-            yield this.writeStatesDB(states);
+    /** Creates the states DB and sets up listeners for it */
+    async createStatesDB() {
+        debug(`creating states DB`);
+        const statesType = this.statesType;
+        debug(`  => states DB type: ${statesType}`);
+        const settings = {
+            connection: {
+                type: statesType,
+                host: "127.0.0.1",
+                port: 19000,
+                options: {
+                    auth_pass: null,
+                    retry_max_delay: 15000,
+                },
+            },
+            logger,
+        };
+        const statesDbPath = require.resolve(`@iobroker/db-states-${statesType}`, {
+            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-var-requires
+        const { Server, Client } = require(statesDbPath);
+        // First create the server
+        await new Promise((resolve) => {
+            this._statesServer = new Server({
+                ...settings,
+                connected: () => {
+                    resolve();
+                },
+            });
+        });
+        // Then the client
+        await new Promise((resolve) => {
+            this._statesClient = new Client({
+                ...settings,
+                connected: () => {
+                    this._statesClient.subscribe("*");
+                    resolve();
+                },
+                change: this.emit.bind(this, "stateChange"),
+            });
         });
+        debug("  => done!");
+    }
+    subscribeMessage(id) {
+        if (!this._statesClient) {
+            throw new Error("States DB is not running");
+        }
+        return this._statesClient.subscribeMessage(id);
+    }
+    pushMessage(instanceId, 
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    msg, callback) {
+        if (!this._statesClient) {
+            throw new Error("States DB is not running");
+        }
+        this._statesClient.pushMessage(instanceId, msg, callback);
+    }
+    async getStateIDs(pattern = "*") {
+        var _a, _b, _c, _d;
+        if (!this._statesClient) {
+            throw new Error("States DB is not running");
+        }
+        return (((_b = (_a = this._statesClient).getKeysAsync) === null || _b === void 0 ? void 0 : _b.call(_a, pattern)) ||
+            ((_d = (_c = this._statesClient).getKeys) === null || _d === void 0 ? void 0 : _d.call(_c, pattern)));
+    }
+    async getObjectIDs(pattern = "*") {
+        var _a, _b, _c, _d;
+        if (!this._objectsClient) {
+            throw new Error("Objects DB is not running");
+        }
+        return (((_b = (_a = this._objectsClient).getKeysAsync) === null || _b === void 0 ? void 0 : _b.call(_a, pattern)) ||
+            ((_d = (_c = this._objectsClient).getKeys) === null || _d === void 0 ? void 0 : _d.call(_c, pattern)));
     }
 }
 exports.DBConnection = DBConnection;

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

@@ -2,6 +2,7 @@
 /// <reference types="node" />
 import { 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;
@@ -14,21 +15,19 @@ export interface TestHarness {
 export declare class TestHarness extends EventEmitter {
     private adapterDir;
     private testDir;
+    private dbConnection;
     /**
      * @param adapterDir The root directory of the adapter
      * @param testDir The directory the integration tests are executed in
      */
-    constructor(adapterDir: string, testDir: string);
+    constructor(adapterDir: string, testDir: string, dbConnection: DBConnection);
     private adapterName;
     private appName;
     private testControllerDir;
     private testAdapterDir;
-    private dbConnection;
-    private _objects;
-    /** The actual objects DB */
+    /** Gives direct access to the Objects DB */
     get objects(): any;
-    private _states;
-    /** The actual states DB */
+    /** Gives direct access to the States DB */
     get states(): any;
     private _adapterProcess;
     /** The process the adapter is running in */
@@ -36,10 +35,6 @@ export declare class TestHarness extends EventEmitter {
     private _adapterExit;
     /** Contains the adapter exit code or signal if it was terminated unexpectedly */
     get adapterExit(): number | string | undefined;
-    /** Creates the objects DB and sets up listeners for it */
-    private createObjectsDB;
-    /** Creates the states DB and sets up listeners for it */
-    private createStatesDB;
     /** Checks if the controller instance is running */
     isControllerRunning(): boolean;
     /** Starts the controller instance by creating the databases */
@@ -65,7 +60,7 @@ export declare class TestHarness extends EventEmitter {
     /**
      * Updates the adapter config. The changes can be a subset of the target object
      */
-    changeAdapterConfig(appName: string, testDir: string, adapterName: string, changes: any): Promise<void>;
+    changeAdapterConfig(adapterName: string, changes: Record<string, any>): Promise<void>;
     /** Enables the sendTo method */
     enableSendTo(): Promise<void>;
     private sendToID;