@iobroker/testing 2.5.2 → 2.5.5

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

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -18,72 +22,284 @@ 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();
+    }
+    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, 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,8 @@ 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>;
+    getAdapterExecutionMode(): ioBroker.AdapterCommon["mode"];
     /** Enables the sendTo method */
     enableSendTo(): Promise<void>;
     private sendToID;

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

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -23,7 +27,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 +34,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 +47,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 +63,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 +92,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 +111,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 +129,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 +203,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,26 +218,25 @@ 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);
         }
     }
+    getAdapterExecutionMode() {
+        return (0, adapterTools_1.getAdapterExecutionMode)(this.testAdapterDir);
+    }
     /** 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) {
@@ -303,7 +247,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/build/tests/integration/lib/tools.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];