@iobroker/testing 2.5.3 → 2.5.4

package/CHANGELOG.md

@@ -4,8 +4,9 @@
 	PLACEHOLDER for next version:
 	## __WORK IN PROGRESS__
 -->
-## 2.5.3 (2022-01-29)
-* Fix: Ensure the tests use the `file` DB type
+## 2.5.4 (2022-02-02)
+* Modifying ioBroker databases now uses the same methods that JS-Controller uses internally. This ensures that the testing is compatible with the `jsonl` database format.
+* Testing adapters with adapter dependencies that try to access the databases during installation now works.
 
 ## 2.5.2 (2021-09-18)
 * Fix: `adminUI.config` is now respected for the config UI check and JSON config is allowed too

package/build/tests/index.js

@@ -8,6 +8,7 @@ const createMocks_1 = require("./unit/harness/createMocks");
 const mockDatabase_1 = require("./unit/mocks/mockDatabase");
 var harness_1 = require("./integration/lib/harness");
 Object.defineProperty(exports, "IntegrationTestHarness", { enumerable: true, get: function () { return harness_1.TestHarness; } });
+var mockAdapter_1 = require("./unit/mocks/mockAdapter");
 var mockDatabase_2 = require("./unit/mocks/mockDatabase");
 Object.defineProperty(exports, "MockDatabase", { enumerable: true, get: function () { return mockDatabase_2.MockDatabase; } });
 /** Predefined test sets */

package/build/tests/integration/index.js

@@ -24,7 +24,6 @@ const async_1 = require("alcalzone-shared/async");
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const adapterTools_1 = require("../../lib/adapterTools");
-const executeCommand_1 = require("../../lib/executeCommand");
 const adapterSetup_1 = require("./lib/adapterSetup");
 const controllerSetup_1 = require("./lib/controllerSetup");
 const dbConnection_1 = require("./lib/dbConnection");
@@ -33,9 +32,10 @@ function testAdapter(adapterDir, options = {}) {
     const appName = (0, adapterTools_1.getAppName)(adapterDir);
     const adapterName = (0, adapterTools_1.getAdapterName)(adapterDir);
     const testDir = path.join(os.tmpdir(), `test-${appName}.${adapterName}`);
+    /** This db connection is only used for the lifetime of a test and then re-created */
+    let dbConnection;
     let harness;
-    const dbConnection = new dbConnection_1.DBConnection(appName, testDir);
-    const controllerSetup = new controllerSetup_1.ControllerSetup(adapterDir, testDir, dbConnection);
+    const controllerSetup = new controllerSetup_1.ControllerSetup(adapterDir, testDir);
     console.log();
     console.log(`Running tests in ${testDir}`);
     console.log();
@@ -49,46 +49,44 @@ function testAdapter(adapterDir, options = {}) {
             if (await controllerSetup.isJsControllerRunning()) {
                 throw new Error("JS-Controller is already running! Stop it for the first test run and try again!");
             }
-            const adapterSetup = new adapterSetup_1.AdapterSetup(adapterDir, testDir, dbConnection);
+            const adapterSetup = new adapterSetup_1.AdapterSetup(adapterDir, testDir);
+            // Installation happens in two steps:
+            // First we need to set up JS Controller, so the databases etc. can be created
             // First we need to copy all files and execute an npm install
             await controllerSetup.prepareTestDir();
-            await adapterSetup.copyAdapterFilesToTestDir();
-            // Remember if JS-Controller is installed already. If so, we need to call setup first later
-            const wasJsControllerInstalled = await controllerSetup.isJsControllerInstalled();
-            // Call npm install
-            await (0, executeCommand_1.executeCommand)("npm", ["i", "--production"], {
-                cwd: testDir,
-            });
-            // Prepare/clean the databases and config
-            if (wasJsControllerInstalled)
-                await controllerSetup.setupJsController();
-            await controllerSetup.setupSystemConfig();
-            await controllerSetup.disableAdminInstances();
-            await adapterSetup.deleteOldInstances();
+            // Only then we can install the adapter, because some (including VIS) try to access
+            // the databases if JS Controller is installed
+            await adapterSetup.installAdapterInTestDir();
+            const dbConnection = new dbConnection_1.DBConnection(appName, testDir);
+            await dbConnection.start();
+            controllerSetup.setupSystemConfig(dbConnection);
+            await controllerSetup.disableAdminInstances(dbConnection);
+            await adapterSetup.deleteOldInstances(dbConnection);
             await adapterSetup.addAdapterInstance();
+            await dbConnection.stop();
             // Create a copy of the databases that we can restore later
             ({ objects: objectsBackup, states: statesBackup } =
-                await dbConnection.readDB());
+                await dbConnection.backup());
         });
         beforeEach(async function () {
             this.timeout(30000);
+            dbConnection = new dbConnection_1.DBConnection(appName, testDir);
             // Clean up before every single test
             await Promise.all([
                 controllerSetup.clearDBDir(),
                 controllerSetup.clearLogDir(),
-                dbConnection.writeDB(objectsBackup, statesBackup),
+                dbConnection.restore(objectsBackup, statesBackup),
             ]);
             // Create a new test harness
-            harness = new harness_1.TestHarness(adapterDir, testDir);
+            await dbConnection.start();
+            harness = new harness_1.TestHarness(adapterDir, testDir, dbConnection);
             // Enable the adapter and set its loglevel to debug
-            await harness.changeAdapterConfig(appName, testDir, adapterName, {
+            await harness.changeAdapterConfig(adapterName, {
                 common: {
                     enabled: true,
                     loglevel: "debug",
                 },
             });
-            // Start the controller instance
-            await harness.startController();
             // And enable the sendTo emulation
             await harness.enableSendTo();
         });

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

@@ -2,8 +2,7 @@ import type { DBConnection } from "./dbConnection";
 export declare class AdapterSetup {
     private adapterDir;
     private testDir;
-    private dbConnection;
-    constructor(adapterDir: string, testDir: string, dbConnection: DBConnection);
+    constructor(adapterDir: string, testDir: string);
     private testAdapterDir;
     private adapterName;
     private adapterFullName;
@@ -14,10 +13,10 @@ export declare class AdapterSetup {
      */
     isAdapterInstalled(): Promise<boolean>;
     /** Copies all adapter files (except a few) to the test directory */
-    copyAdapterFilesToTestDir(): Promise<void>;
+    installAdapterInTestDir(): Promise<void>;
     /**
      * Adds an instance for an already installed adapter in the test directory
      */
     addAdapterInstance(): Promise<void>;
-    deleteOldInstances(): Promise<void>;
+    deleteOldInstances(dbConnection: DBConnection): Promise<void>;
 }

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

@@ -23,6 +23,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdapterSetup = void 0;
+/* eslint-disable @typescript-eslint/no-empty-function */
 // Add debug logging for tests
 const objects_1 = require("alcalzone-shared/objects");
 const debug_1 = __importDefault(require("debug"));
@@ -33,10 +34,9 @@ const executeCommand_1 = require("../../../lib/executeCommand");
 const tools_1 = require("./tools");
 const debug = (0, debug_1.default)("testing:integration:AdapterSetup");
 class AdapterSetup {
-    constructor(adapterDir, testDir, dbConnection) {
+    constructor(adapterDir, testDir) {
         this.adapterDir = adapterDir;
         this.testDir = testDir;
-        this.dbConnection = dbConnection;
         debug("Creating AdapterSetup...");
         this.adapterName = (0, adapterTools_1.getAdapterName)(this.adapterDir);
         this.adapterFullName = (0, adapterTools_1.getAdapterFullName)(this.adapterDir);
@@ -57,7 +57,7 @@ class AdapterSetup {
         return (0, fs_extra_1.pathExists)(this.testAdapterDir);
     }
     /** Copies all adapter files (except a few) to the test directory */
-    async copyAdapterFilesToTestDir() {
+    async installAdapterInTestDir() {
         debug("Copying adapter files to test directory...");
         // We install the adapter almost like it would be installed in the real world
         // Therefore pack it into a tarball and put it in the test dir for installation
@@ -87,6 +87,11 @@ class AdapterSetup {
         debug("Deleting old remains of this adapter");
         if (await (0, fs_extra_1.pathExists)(this.testAdapterDir))
             await (0, fs_extra_1.remove)(this.testAdapterDir);
+        debug("Installing adapter");
+        // Defer to npm to install the controller (if it wasn't already)
+        await (0, executeCommand_1.executeCommand)("npm", ["i", "--production"], {
+            cwd: this.testDir,
+        });
         debug("  => done!");
     }
     /**
@@ -109,9 +114,12 @@ class AdapterSetup {
             throw new Error(`Adding the adapter instance failed!`);
         debug("  => done!");
     }
-    async deleteOldInstances() {
+    async deleteOldInstances(dbConnection) {
         debug("Removing old adapter instances...");
-        const { objects, states } = await this.dbConnection.readDB();
+        const allKeys = new Set([
+            ...(await dbConnection.getObjectIDs()),
+            ...(await dbConnection.getStateIDs()),
+        ]);
         const instanceRegex = new RegExp(`^system\\.adapter\\.${this.adapterName}\\.\\d+`);
         const instanceObjsRegex = new RegExp(`^${this.adapterName}\\.\\d+\.`);
         const belongsToAdapter = (id) => {
@@ -120,19 +128,12 @@ class AdapterSetup {
                 id === this.adapterName ||
                 id === `${this.adapterName}.admin`);
         };
-        if (objects) {
-            for (const id of Object.keys(objects)) {
-                if (belongsToAdapter(id))
-                    delete objects[id];
-            }
-        }
-        if (states) {
-            for (const id of Object.keys(states)) {
-                if (belongsToAdapter(id))
-                    delete states[id];
-            }
+        const idsToDelete = [...allKeys].filter((id) => belongsToAdapter(id));
+        for (const id of idsToDelete) {
+            await dbConnection.delObject(id).catch(() => { });
+            await dbConnection.delState(id).catch(() => { });
         }
-        await this.dbConnection.writeDB(objects, states);
+        debug("  => done!");
     }
 }
 exports.AdapterSetup = AdapterSetup;

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

@@ -2,8 +2,7 @@ import type { DBConnection } from "./dbConnection";
 export declare class ControllerSetup {
     private adapterDir;
     private testDir;
-    private dbConnection;
-    constructor(adapterDir: string, testDir: string, dbConnection: DBConnection);
+    constructor(adapterDir: string, testDir: string);
     private appName;
     private adapterName;
     private testAdapterDir;
@@ -22,8 +21,6 @@ export declare class ControllerSetup {
     isJsControllerRunning(): Promise<boolean>;
     /**
      * Sets up an existing JS-Controller instance for testing by executing "iobroker setup first"
-     * @param appName The branded name of "iobroker"
-     * @param testDir The directory the integration tests are executed in
      */
     setupJsController(): Promise<void>;
     /**
@@ -31,7 +28,7 @@ export declare class ControllerSetup {
      * @param appName The branded name of "iobroker"
      * @param testDir The directory the integration tests are executed in
      */
-    setupSystemConfig(): Promise<void>;
+    setupSystemConfig(dbConnection: DBConnection): void;
     /**
      * Clears the log dir for integration tests (and creates it if it doesn't exist)
      * @param appName The branded name of "iobroker"
@@ -48,5 +45,5 @@ export declare class ControllerSetup {
      * Disables all admin instances in the objects DB
      * @param objects The contents of objects.json
      */
-    disableAdminInstances(): Promise<void>;
+    disableAdminInstances(dbConnection: DBConnection): Promise<void>;
 }

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

@@ -23,7 +23,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ControllerSetup = void 0;
-/* eslint-disable @typescript-eslint/no-var-requires */
 // Add debug logging for tests
 const debug_1 = __importDefault(require("debug"));
 const fs_extra_1 = require("fs-extra");
@@ -34,10 +33,9 @@ const executeCommand_1 = require("../../../lib/executeCommand");
 const tools_1 = require("./tools");
 const debug = (0, debug_1.default)("testing:integration:ControllerSetup");
 class ControllerSetup {
-    constructor(adapterDir, testDir, dbConnection) {
+    constructor(adapterDir, testDir) {
         this.adapterDir = adapterDir;
         this.testDir = testDir;
-        this.dbConnection = dbConnection;
         debug("Creating ControllerSetup...");
         this.adapterName = (0, adapterTools_1.getAdapterName)(this.adapterDir);
         this.appName = (0, adapterTools_1.getAppName)(this.adapterDir);
@@ -83,6 +81,16 @@ class ControllerSetup {
         if (nodeMajorVersion >= 10) {
             await (0, fs_extra_1.writeFile)(path.join(this.testDir, ".npmrc"), "engine-strict=true", "utf8");
         }
+        // Remember if JS-Controller is installed already. If so, we need to call `setup first` afterwards
+        const wasJsControllerInstalled = await this.isJsControllerInstalled();
+        // Defer to npm to install the controller (if it wasn't already)
+        debug("(Re-)installing JS Controller...");
+        await (0, executeCommand_1.executeCommand)("npm", ["i", "--production"], {
+            cwd: this.testDir,
+        });
+        // Prepare/clean the databases and config
+        if (wasJsControllerInstalled)
+            await this.setupJsController();
         debug("  => done!");
     }
     /**
@@ -152,8 +160,6 @@ class ControllerSetup {
     // }
     /**
      * Sets up an existing JS-Controller instance for testing by executing "iobroker setup first"
-     * @param appName The branded name of "iobroker"
-     * @param testDir The directory the integration tests are executed in
      */
     async setupJsController() {
         debug("Initializing JS-Controller installation...");
@@ -175,15 +181,12 @@ class ControllerSetup {
      * @param appName The branded name of "iobroker"
      * @param testDir The directory the integration tests are executed in
      */
-    async setupSystemConfig() {
-        debug(`Moving databases to different ports and setting type "file"...`);
-        const systemFilename = path.join(this.testDataDir, `${this.appName}.json`);
-        const systemConfig = require(systemFilename);
+    setupSystemConfig(dbConnection) {
+        debug(`Moving databases to different ports...`);
+        const systemConfig = dbConnection.getSystemConfig();
         systemConfig.objects.port = 19001;
-        systemConfig.objects.type = "file";
         systemConfig.states.port = 19000;
-        systemConfig.states.type = "file";
-        await (0, fs_extra_1.writeFile)(systemFilename, JSON.stringify(systemConfig, null, 2));
+        dbConnection.setSystemConfig(systemConfig);
         debug("  => done!");
     }
     /**
@@ -208,18 +211,17 @@ class ControllerSetup {
      * Disables all admin instances in the objects DB
      * @param objects The contents of objects.json
      */
-    async disableAdminInstances() {
+    async disableAdminInstances(dbConnection) {
         debug("Disabling admin instances...");
-        const objects = await this.dbConnection.readObjectsDB();
-        if (objects) {
-            for (const id of Object.keys(objects)) {
-                if (/^system\.adapter\.admin\.\d.+$/.test(id)) {
-                    const obj = objects[id];
-                    if (obj && obj.common)
-                        obj.common.enabled = false;
-                }
+        const instanceObjects = await dbConnection.getObjectViewAsync("system", "instance", {
+            startkey: "system.adapter.admin.",
+            endkey: "system.adapter.admin.\u9999",
+        });
+        for (const { id, value: obj } of instanceObjects.rows) {
+            if (obj && obj.common) {
+                obj.common.enabled = false;
+                await dbConnection.setObject(id, obj);
             }
-            await this.dbConnection.writeObjectsDB(objects);
         }
         debug("  => done!");
     }

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

@@ -1,8 +1,14 @@
 /// <reference types="iobroker" />
+/// <reference types="node" />
+import EventEmitter from "events";
 export declare type ObjectsDB = Record<string, ioBroker.Object>;
 export declare type StatesDB = Record<string, ioBroker.State>;
-/** The DB connection capsules access to the objects.json and states.json on disk */
-export declare class DBConnection {
+export interface DBConnection {
+    on(event: "objectChange", handler: ioBroker.ObjectChangeHandler): this;
+    on(event: "stateChange", handler: ioBroker.StateChangeHandler): this;
+}
+/** The DB connection capsules access to the states and objects DB */
+export declare class DBConnection extends EventEmitter {
     private appName;
     private testDir;
     /**
@@ -11,25 +17,43 @@ export declare class DBConnection {
      */
     constructor(appName: string, testDir: string);
     private testDataDir;
-    private objectsPath;
-    private statesPath;
-    readObjectsDB(): Promise<Record<string, ioBroker.Object> | undefined>;
-    writeObjectsDB(objects: ObjectsDB | undefined): Promise<void>;
-    writeStatesDB(states: StatesDB | undefined): Promise<void>;
-    readStatesDB(): Promise<any>;
-    /**
-     * 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
-     */
-    readDB(): Promise<{
-        objects: Record<string, ioBroker.Object> | undefined;
-        states: any;
+    private testControllerDir;
+    private _objectsServer;
+    private _statesServer;
+    private _objectsClient;
+    /** The underlying objects client instance that can be used to access the objects DB */
+    get objectsClient(): any;
+    private _statesClient;
+    /** The underlying states client instance that can be used to access the states DB */
+    get statesClient(): any;
+    get objectsType(): "file" | "jsonl";
+    get objectsPath(): string;
+    get statesType(): "file" | "jsonl";
+    get statesPath(): string;
+    getSystemConfig(): any;
+    backup(): Promise<{
+        objects: Buffer;
+        states: Buffer;
     }>;
-    /**
-     * 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: any, states: any): Promise<void>;
+    restore(objects: Buffer, states: Buffer): Promise<void>;
+    setSystemConfig(systemConfig: any): void;
+    private _isRunning;
+    get isRunning(): boolean;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** Creates the objects DB and sets up listeners for it */
+    private createObjectsDB;
+    /** Creates the states DB and sets up listeners for it */
+    private createStatesDB;
+    readonly getObject: ioBroker.Adapter["getForeignObjectAsync"];
+    readonly setObject: ioBroker.Adapter["setForeignObjectAsync"];
+    readonly delObject: ioBroker.Adapter["delForeignObjectAsync"];
+    readonly getState: ioBroker.Adapter["getForeignStateAsync"];
+    readonly setState: ioBroker.Adapter["setForeignStateAsync"];
+    readonly delState: ioBroker.Adapter["delForeignStateAsync"];
+    subscribeMessage(id: string): void;
+    pushMessage(instanceId: string, msg: any, callback: (err: Error | null, id: any) => void): void;
+    readonly getObjectViewAsync: ioBroker.Adapter["getObjectViewAsync"];
+    getStateIDs(pattern?: string): Promise<string[]>;
+    getObjectIDs(pattern?: string): Promise<string[]>;
 }

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

@@ -18,72 +18,287 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+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._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);
-        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
-    async readObjectsDB() {
-        // debug(`reading objects db...`);
-        // debug(`  dataDir:     ${dataDir}`);
-        // debug(`  objectsPath: ${objectsPath}`);
-        if (await (0, fs_extra_1.pathExists)(this.objectsPath)) {
-            // debug(`  exists:      true`);
-            return (0, fs_extra_1.readJSON)(this.objectsPath, { encoding: "utf8" });
-        }
     }
-    async writeObjectsDB(objects) {
-        if (!objects)
+    /** The underlying objects client instance that can be used to access the objects DB */
+    get objectsClient() {
+        return this._objectsClient;
+    }
+    /** The underlying states client instance that can be used to access the states DB */
+    get statesClient() {
+        return this._statesClient;
+    }
+    get objectsType() {
+        return this.getSystemConfig().objects.type;
+    }
+    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;
-        return (0, fs_extra_1.writeJSON)(this.objectsPath, objects);
+        }
+        debug("starting DB instances...");
+        await this.createObjectsDB();
+        await this.createStatesDB();
+        this._isRunning = true;
+        debug("DB instances started");
     }
-    async writeStatesDB(states) {
-        if (!states)
+    async stop() {
+        var _a, _b, _c, _d;
+        if (!this._isRunning) {
+            debug("No DB instance is running, nothing to stop...");
             return;
-        return (0, fs_extra_1.writeJSON)(this.statesPath, states);
-    }
-    async readStatesDB() {
-        // debug(`reading states db...`);
-        // debug(`  dataDir:     ${dataDir}`);
-        // debug(`  statesPath:  ${statesPath}`);
-        if (await (0, fs_extra_1.pathExists)(this.statesPath)) {
-            // debug(`  exists:      true`);
-            return (0, fs_extra_1.readJSON)(this.statesPath, { encoding: "utf8" });
         }
+        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 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
-    async readDB() {
-        const objects = await this.readObjectsDB();
-        const states = await this.readStatesDB();
-        return { objects, states };
+    /** 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
-     */
-    async writeDB(objects, states) {
-        await this.writeObjectsDB(objects);
-        await 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;

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

@@ -23,7 +23,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestHarness = void 0;
-/* eslint-disable @typescript-eslint/no-var-requires */
 const async_1 = require("alcalzone-shared/async");
 const objects_1 = require("alcalzone-shared/objects");
 const child_process_1 = require("child_process");
@@ -31,18 +30,9 @@ const debug_1 = __importDefault(require("debug"));
 const events_1 = require("events");
 const path = __importStar(require("path"));
 const adapterTools_1 = require("../../../lib/adapterTools");
-const dbConnection_1 = require("./dbConnection");
 const tools_1 = require("./tools");
 const debug = (0, debug_1.default)("testing:integration:TestHarness");
 const isWindows = /^win/.test(process.platform);
-/** 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,
-};
 const fromAdapterID = "system.adapter.test.0";
 /**
  * The test harness capsules the execution of the JS-Controller and the adapter instance and monitors their status.
@@ -53,10 +43,11 @@ class TestHarness extends events_1.EventEmitter {
      * @param adapterDir The root directory of the adapter
      * @param testDir The directory the integration tests are executed in
      */
-    constructor(adapterDir, testDir) {
+    constructor(adapterDir, testDir, dbConnection) {
         super();
         this.adapterDir = adapterDir;
         this.testDir = testDir;
+        this.dbConnection = dbConnection;
         this.sendToID = 1;
         debug("Creating instance");
         this.adapterName = (0, adapterTools_1.getAdapterName)(this.adapterDir);
@@ -68,15 +59,26 @@ class TestHarness extends events_1.EventEmitter {
         debug(`    adapter:    ${this.testAdapterDir}`);
         debug(`  appName:           ${this.appName}`);
         debug(`  adapterName:       ${this.adapterName}`);
-        this.dbConnection = new dbConnection_1.DBConnection(this.appName, this.testDir);
+        dbConnection.on("objectChange", (id, obj) => {
+            this.emit("objectChange", id, obj);
+        });
+        dbConnection.on("stateChange", (id, state) => {
+            this.emit("stateChange", id, state);
+        });
     }
-    /** The actual objects DB */
+    /** Gives direct access to the Objects DB */
     get objects() {
-        return this._objects;
+        if (!this.dbConnection.objectsClient) {
+            throw new Error("Objects DB is not running");
+        }
+        return this.dbConnection.objectsClient;
     }
-    /** The actual states DB */
+    /** Gives direct access to the States DB */
     get states() {
-        return this._states;
+        if (!this.dbConnection.statesClient) {
+            throw new Error("States DB is not running");
+        }
+        return this.dbConnection.statesClient;
     }
     /** The process the adapter is running in */
     get adapterProcess() {
@@ -86,68 +88,15 @@ class TestHarness extends events_1.EventEmitter {
     get adapterExit() {
         return this._adapterExit;
     }
-    /** Creates the objects DB and sets up listeners for it */
-    async createObjectsDB() {
-        debug("creating objects DB");
-        const Objects = require(path.join(this.testControllerDir, "lib/objects/objectsInMemServer"));
-        return new Promise((resolve) => {
-            this._objects = new Objects({
-                connection: {
-                    type: "file",
-                    host: "127.0.0.1",
-                    port: 19001,
-                    user: "",
-                    pass: "",
-                    noFileCache: false,
-                    connectTimeout: 2000,
-                },
-                logger,
-                connected: () => {
-                    debug("  => done!");
-                    this._objects.subscribe("*");
-                    resolve();
-                },
-                change: this.emit.bind(this, "objectChange"),
-            });
-        });
-    }
-    /** Creates the states DB and sets up listeners for it */
-    async createStatesDB() {
-        debug("creating states DB");
-        const States = require(path.join(this.testControllerDir, "lib/states/statesInMemServer"));
-        return new Promise((resolve) => {
-            this._states = new States({
-                connection: {
-                    type: "file",
-                    host: "127.0.0.1",
-                    port: 19000,
-                    options: {
-                        auth_pass: null,
-                        retry_max_delay: 15000,
-                    },
-                },
-                logger,
-                connected: () => {
-                    debug("  => done!");
-                    this._states.subscribe("*");
-                    resolve();
-                },
-                change: this.emit.bind(this, "stateChange"),
-            });
-        });
-    }
     /** Checks if the controller instance is running */
     isControllerRunning() {
-        return !!this._objects || !!this._states;
+        // The "controller instance" is just the databases, so if they are running,
+        // the "controller" is.
+        return this.dbConnection.isRunning;
     }
     /** Starts the controller instance by creating the databases */
     async startController() {
-        debug("starting controller instance...");
-        if (this.isControllerRunning())
-            throw new Error("The Controller is already running!");
-        await this.createObjectsDB();
-        await this.createStatesDB();
-        debug("controller instance created");
+        await this.dbConnection.start();
     }
     /** Stops the controller instance (and the adapter if it is running) */
     async stopController() {
@@ -158,7 +107,7 @@ class TestHarness extends events_1.EventEmitter {
             // Give the adapter time to stop (as long as configured in the io-package.json)
             let stopTimeout;
             try {
-                stopTimeout = (await this._objects.getObjectAsync(`system.adapter.${this.adapterName}.0`)).common.stopTimeout;
+                stopTimeout = (await this.dbConnection.getObject(`system.adapter.${this.adapterName}.0`)).common.stopTimeout;
                 stopTimeout += 1000;
             }
             catch { }
@@ -176,16 +125,7 @@ class TestHarness extends events_1.EventEmitter {
         else {
             debug("Adapter failed to start - no need to terminate!");
         }
-        debug("Stopping controller instance...");
-        if (this._objects) {
-            await this._objects.destroy();
-            this._objects = null;
-        }
-        if (this._states) {
-            await this._states.destroy();
-            this._states = null;
-        }
-        debug("Controller instance stopped");
+        await this.dbConnection.stop();
     }
     /**
      * Starts the adapter in a separate process and monitors its status
@@ -259,13 +199,14 @@ class TestHarness extends events_1.EventEmitter {
                 .on("close", onClose)
                 .on("exit", onClose);
             // Tell adapter to stop
-            if (this._states) {
-                await this._states.setStateAsync(`system.adapter.${this.adapterName}.0.sigKill`, {
+            try {
+                await this.dbConnection.setState(`system.adapter.${this.adapterName}.0.sigKill`, {
                     val: -1,
                     from: "system.host.testing",
                 });
             }
-            else {
+            catch {
+                // DB connection may be closed already, kill the process
                 (_a = this._adapterProcess) === null || _a === void 0 ? void 0 : _a.kill("SIGTERM");
             }
         });
@@ -273,29 +214,27 @@ class TestHarness extends events_1.EventEmitter {
     /**
      * Updates the adapter config. The changes can be a subset of the target object
      */
-    async changeAdapterConfig(appName, testDir, adapterName, changes) {
-        const objects = await this.dbConnection.readObjectsDB();
+    async changeAdapterConfig(adapterName, changes) {
         const adapterInstanceId = `system.adapter.${adapterName}.0`;
-        if (objects && adapterInstanceId in objects) {
-            const target = objects[adapterInstanceId];
-            (0, objects_1.extend)(target, changes);
-            await this.dbConnection.writeObjectsDB(objects);
+        const obj = await this.dbConnection.getObject(adapterInstanceId);
+        if (obj) {
+            (0, objects_1.extend)(obj, changes);
+            await this.dbConnection.setObject(adapterInstanceId, obj);
         }
     }
     /** Enables the sendTo method */
-    enableSendTo() {
-        return new Promise((resolve) => {
-            this._objects.extendObject(fromAdapterID, {
-                common: {},
-                type: "instance",
-            }, () => {
-                this._states.subscribeMessage(fromAdapterID);
-                resolve();
-            });
+    async enableSendTo() {
+        await this.dbConnection.setObject(fromAdapterID, {
+            type: "instance",
+            common: {},
+            native: {},
         });
+        this.dbConnection.subscribeMessage(fromAdapterID);
     }
     /** Sends a message to an adapter instance */
-    sendTo(target, command, message, callback) {
+    sendTo(target, command, 
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    message, callback) {
         const stateChangedHandler = (id, state) => {
             if (id === `messagebox.${fromAdapterID}`) {
                 callback(state.message);
@@ -303,7 +242,7 @@ class TestHarness extends events_1.EventEmitter {
             }
         };
         this.addListener("stateChange", stateChangedHandler);
-        this._states.pushMessage(`system.adapter.${target}`, {
+        this.dbConnection.pushMessage(`system.adapter.${target}`, {
             command: command,
             message: message,
             from: fromAdapterID,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iobroker/testing",
-  "version": "2.5.3",
+  "version": "2.5.4",
   "description": "Shared utilities for adapter and module testing in ioBroker",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -42,7 +42,7 @@
     "@alcalzone/release-script-plugin-license": "^3.5.0",
     "@iobroker/adapter-core": "^2.5.1",
     "@tsconfig/node12": "^1.0.9",
-    "@types/chai": "^4.2.22",
+    "@types/chai": "^4.3.0",
     "@types/chai-as-promised": "^7.1.4",
     "@types/debug": "4.1.7",
     "@types/fs-extra": "^9.0.13",
@@ -56,11 +56,11 @@
     "eslint": "^7.32.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-prettier": "^4.0.0",
-    "prettier": "^2.4.1",
+    "prettier": "^2.5.1",
     "rimraf": "^3.0.2",
     "source-map-support": "^0.5.21",
     "ts-node": "^10.2.1",
-    "typescript": "~4.4.4"
+    "typescript": "~4.5.5"
   },
   "dependencies": {
     "alcalzone-shared": "~4.0.1",