@xenon-device-management/xenon 2.13.1 → 2.14.0

package/lib/test/unit/dashboard-commands.spec.js

@@ -0,0 +1,249 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = 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];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __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 });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const assetManager = __importStar(require("../../src/dashboard/asset-manager"));
+const commands_1 = require("../../src/dashboard/commands");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const SocketServer_1 = require("../../src/services/SocketServer");
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * The five execute commands that write to a session's record:
+ * setSessionName, setSessionStatus, debug, addTag and captureEvidence.
+ *
+ * A session has a record (a Session row) only on a hub with its dashboard
+ * on. Elsewhere (the dashboard off, or on a node, which never keeps one for
+ * the hub's sessions) setSessionName and setSessionStatus threw Prisma's
+ * P2025 and debug a foreign-key error, failing the test's command, while
+ * addTag and captureEvidence answered as if they had worked.
+ *
+ * Each now answers `{ recorded: true }` when it wrote, or `{ recorded: false,
+ * message }` saying why nothing was written. None of them fails the test's
+ * command: they are bookkeeping, and a test shouldn't die because its server
+ * keeps no dashboard.
+ */
+describe('xenon: session-details commands', () => {
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const SESSION = 'session-details-1';
+    let restoreContainer;
+    let emitted;
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        yield scratch.db.log.deleteMany({});
+        yield scratch.db.sessionLog.deleteMany({});
+        yield scratch.db.session.deleteMany({});
+        restoreContainer = (0, container_registration_1.saveRegistrations)(SocketServer_1.SocketServer);
+        const socket = new SocketServer_1.SocketServer();
+        typedi_1.Container.set(SocketServer_1.SocketServer, socket);
+        emitted = sinon_1.default.stub(socket, 'emitToDashboardForDevices').resolves();
+    }));
+    afterEach(() => {
+        SessionManager_1.SESSION_MANAGER.removeSession(SESSION);
+        sinon_1.default.restore();
+        restoreContainer();
+    });
+    function withRecord() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield scratch.db.session.create({
+                data: {
+                    id: SESSION,
+                    desired_capabilities: '{}',
+                    session_capabilities: '{}',
+                    node_id: 'node-1',
+                    has_live_video: false,
+                    device_udid: 'phone-1',
+                    device_platform: 'android',
+                    device_version: '14',
+                },
+            });
+        });
+    }
+    /** What the command answers, as the local interceptor and the hub's gateway both see it. */
+    function run(script, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let body;
+            const response = {
+                status: (code) => ({
+                    json: (d) => {
+                        body = Object.assign({ code }, d);
+                        return d;
+                    },
+                }),
+            };
+            yield commands_1.dashboardCommands.process(SESSION, { body: { script, args } }, response);
+            return body;
+        });
+    }
+    describe('which scripts are session-details commands', () => {
+        it('knows the five, under either prefix, and nothing else', () => {
+            (0, chai_1.expect)((0, commands_1.sessionDetailsCommandOf)('xenon: setSessionName')).to.equal('setSessionName');
+            (0, chai_1.expect)((0, commands_1.sessionDetailsCommandOf)('xe:addTag')).to.equal('addTag');
+            (0, chai_1.expect)((0, commands_1.sessionDetailsCommandOf)(' xenon :  captureEvidence ')).to.equal('captureEvidence');
+            for (const other of [
+                'xenon: smartTap',
+                'xe: setAutowaitProperties',
+                'xenon: addMock',
+                'xenon: unknownThing',
+                'mobile: shell',
+                'xenonsetSessionName',
+                'return 1',
+                undefined,
+                42,
+            ]) {
+                (0, chai_1.expect)((0, commands_1.sessionDetailsCommandOf)(other), String(other)).to.equal(null);
+            }
+        });
+    });
+    describe('with no session record', () => {
+        const cases = [
+            ['xenon: setSessionName', ['Checkout']],
+            ['xenon: setSessionStatus', [{ status: 'passed' }]],
+            ['xenon: debug', ['reached checkout']],
+            ['xenon: addTag', ['smoke']],
+            ['xenon: captureEvidence', ['Payment confirmed']],
+        ];
+        for (const [script, args] of cases) {
+            it(`${script} answers that nothing was recorded, and writes nothing`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const body = yield run(script, args);
+                (0, chai_1.expect)(body.code).to.equal(200);
+                (0, chai_1.expect)(body.value).to.include({ recorded: false });
+                (0, chai_1.expect)(body.value.message).to.match(/no record/i);
+                (0, chai_1.expect)(yield scratch.db.log.count()).to.equal(0);
+                (0, chai_1.expect)(yield scratch.db.sessionLog.count()).to.equal(0);
+            }));
+        }
+    });
+    describe('with a session record', () => {
+        beforeEach(withRecord);
+        it('setSessionName names the session', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, _b;
+            (0, chai_1.expect)((yield run('xenon: setSessionName', ['Checkout'])).value).to.deep.equal({
+                recorded: true,
+            });
+            (0, chai_1.expect)((_a = (yield scratch.db.session.findUnique({ where: { id: SESSION } }))) === null || _a === void 0 ? void 0 : _a.name).to.equal('Checkout');
+            yield run('xe: setSessionName', [{ name: 'Checkout by card' }]);
+            (0, chai_1.expect)((_b = (yield scratch.db.session.findUnique({ where: { id: SESSION } }))) === null || _b === void 0 ? void 0 : _b.name).to.equal('Checkout by card');
+        }));
+        it('setSessionName without a name records nothing, and says so', () => __awaiter(void 0, void 0, void 0, function* () {
+            const body = yield run('xenon: setSessionName', []);
+            (0, chai_1.expect)(body.value).to.include({ recorded: false });
+            (0, chai_1.expect)(body.value.message).to.match(/name/);
+        }));
+        it('setSessionStatus sets the status and reason, and tells the dashboard', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const body = yield run('xenon: setSessionStatus', [{ status: 'failed', reason: 'No total' }]);
+            (0, chai_1.expect)(body.value).to.deep.equal({ recorded: true });
+            const row = yield scratch.db.session.findUnique({ where: { id: SESSION } });
+            (0, chai_1.expect)(row).to.include({ status: 'failed', failure_reason: 'No total' });
+            (0, chai_1.expect)(emitted.firstCall.args[1]).to.include({
+                id: SESSION,
+                status: 'failed',
+                failure_reason: 'No total',
+            });
+            yield run('xenon: setSessionStatus', ['passed']);
+            (0, chai_1.expect)((_a = (yield scratch.db.session.findUnique({ where: { id: SESSION } }))) === null || _a === void 0 ? void 0 : _a.status).to.equal('success');
+        }));
+        it('setSessionStatus with a status it does not know records nothing, and says so', () => __awaiter(void 0, void 0, void 0, function* () {
+            var _a;
+            const body = yield run('xenon: setSessionStatus', [{ status: 'skipped' }]);
+            (0, chai_1.expect)(body.value).to.include({ recorded: false });
+            (0, chai_1.expect)(body.value.message).to.match(/skipped/);
+            (0, chai_1.expect)((_a = (yield scratch.db.session.findUnique({ where: { id: SESSION } }))) === null || _a === void 0 ? void 0 : _a.status).to.equal('running');
+        }));
+        it('debug adds a debug line', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)((yield run('xenon: debug', ['reached checkout'])).value).to.deep.equal({
+                recorded: true,
+            });
+            yield run('xenon: debug', [{ message: 'paid' }]);
+            const lines = yield scratch.db.log.findMany({ orderBy: { createdAt: 'asc' } });
+            (0, chai_1.expect)(lines.map((l) => [l.log_type, l.message])).to.deep.equal([
+                ['DEBUG', 'reached checkout'],
+                ['DEBUG', 'paid'],
+            ]);
+        }));
+        it('debug without a message records nothing, and says so', () => __awaiter(void 0, void 0, void 0, function* () {
+            const body = yield run('xenon: debug', []);
+            (0, chai_1.expect)(body.value).to.include({ recorded: false });
+            (0, chai_1.expect)(yield scratch.db.log.count()).to.equal(0);
+        }));
+        it('addTag adds a tag once', () => __awaiter(void 0, void 0, void 0, function* () {
+            (0, chai_1.expect)((yield run('xenon: addTag', ['smoke'])).value).to.deep.equal({ recorded: true });
+            (0, chai_1.expect)((yield run('xenon: addTag', [{ tag: 'smoke' }])).value).to.deep.equal({
+                recorded: true,
+            });
+            yield run('xenon: addTag', ['regression']);
+            const row = yield scratch.db.session.findUnique({ where: { id: SESSION } });
+            (0, chai_1.expect)(JSON.parse(String(row === null || row === void 0 ? void 0 : row.tags))).to.deep.equal(['smoke', 'regression']);
+        }));
+        it('captureEvidence records a screenshot of a session this server drives', () => __awaiter(void 0, void 0, void 0, function* () {
+            SessionManager_1.SESSION_MANAGER.addSession(SESSION, { getScreenShot: () => __awaiter(void 0, void 0, void 0, function* () { return 'aGVsbG8='; }) });
+            sinon_1.default.stub(assetManager, 'saveScreenShot').returns(`${SESSION}/screenshots/x.png`);
+            const body = yield run('xenon: captureEvidence', [{ reason: 'Paid', label: 'receipt' }]);
+            (0, chai_1.expect)(body.value).to.deep.equal({ recorded: true });
+            const rows = yield scratch.db.sessionLog.findMany({});
+            (0, chai_1.expect)(rows.map((r) => [r.command_name, r.subtitle, r.screenshot])).to.deep.equal([
+                ['captureEvidence', 'Paid', `${SESSION}/screenshots/x.png`],
+            ]);
+        }));
+        it("captureEvidence records nothing, and says so, when it can't take a screenshot", () => __awaiter(void 0, void 0, void 0, function* () {
+            let body = yield run('xenon: captureEvidence', ['Paid']);
+            (0, chai_1.expect)(body.value).to.include({ recorded: false });
+            SessionManager_1.SESSION_MANAGER.addSession(SESSION, {
+                getScreenShot: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error('WDA is not running');
+                }),
+            });
+            body = yield run('xenon: captureEvidence', ['Paid']);
+            (0, chai_1.expect)(body.value).to.include({ recorded: false });
+            (0, chai_1.expect)(body.value.message).to.match(/WDA is not running/);
+            (0, chai_1.expect)(yield scratch.db.sessionLog.count()).to.equal(0);
+        }));
+    });
+});

package/lib/test/unit/dashboard-events-team-scope.spec.js

@@ -253,6 +253,8 @@ describe('Dashboard events name their phone (team-scoped call sites)', () => {
                     delete teams[filter.udid];
                 })),
                 updateDevice: sinon_1.default.stub().resolves(),
+                // removeDevice reads the row for the device_offline webhook's name and platform.
+                findDevice: sinon_1.default.stub().resolves(null),
                 getDevices: sinon_1.default.stub().resolves([
                     {
                         udid: 'phone-b',
@@ -308,13 +310,14 @@ describe('Dashboard events name their phone (team-scoped call sites)', () => {
         }));
     });
     it("xenon: setSessionStatus: the updated session's device", () => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.stub(prisma_1.prisma.session, 'findUnique').resolves({ id: 's3', tags: null });
         sinon_1.default.stub(prisma_1.prisma.session, 'update').resolves({ id: 's3', device_udid: 'phone-b' });
         const res = { status: () => res, json: () => res };
         yield new commands_1.DashboardCommands().process('s3', {
             body: { script: 'xenon: setSessionStatus', args: [{ status: 'failed', reason: 'boom' }] },
         }, res);
         const [call] = scoped(SocketEvents_1.SocketEvents.SESSION_STOPPED);
-        (0, chai_1.expect)(call.args[1]).to.deep.equal({ id: 's3', status: 'failed', failure_reason: undefined });
+        (0, chai_1.expect)(call.args[1]).to.deep.equal({ id: 's3', status: 'failed', failure_reason: 'boom' });
         (0, chai_1.expect)(call.args[2]).to.deep.equal({ udid: 'phone-b' });
     }));
     describe('interceptor', () => {
@@ -400,11 +403,10 @@ describe('Dashboard events name their phone (team-scoped call sites)', () => {
     }));
     it('a team change (PUT /device/:udid/team) refreshes the resolver at once', () => __awaiter(void 0, void 0, void 0, function* () {
         sinon_1.default.stub(prisma_1.prisma.team, 'findUnique').resolves({ id: 'team-c' });
-        sinon_1.default.stub(prisma_1.prisma.device, 'updateMany').resolves({ count: 1 });
-        sinon_1.default
-            .stub(prisma_1.prisma.device, 'findMany')
-            .resolves([{ udid: 'phone-a', host: 'h', teamId: 'team-c' }]);
-        sinon_1.default.stub(device_store_1.DeviceStoreFactory.getStore(), 'updateDevice').resolves();
+        const store = device_store_1.DeviceStoreFactory.getStore();
+        sinon_1.default.stub(store, 'findDevices').resolves([{ udid: 'phone-a', host: 'h' }]);
+        sinon_1.default.stub(store, 'findSavedPhones').resolves([]);
+        const write = sinon_1.default.stub(store, 'updateDevice').resolves();
         const resolver = typedi_1.Container.get(DeviceTeamResolver_1.DeviceTeamResolver);
         yield resolver.resolve('phone-a'); // cached as team-a
         const app = (0, express_1.default)();
@@ -424,6 +426,7 @@ describe('Dashboard events name their phone (team-scoped call sites)', () => {
         app.use(router);
         const res = yield (0, loopbackRequest_1.default)(app).put('/device/phone-a/team').send({ teamId: 'team-c' });
         (0, chai_1.expect)(res.status).to.equal(200);
+        (0, chai_1.expect)(write.firstCall.args).to.deep.equal(['phone-a', 'h', { teamId: 'team-c' }]);
         (0, chai_1.expect)(yield resolver.resolve('phone-a')).to.deep.equal({ known: true, teamId: 'team-c' });
         (0, chai_1.expect)(lookups).to.deep.equal(['phone-a']);
     }));

package/lib/test/unit/database-check.spec.js

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const config_1 = require("../../src/config");
+const logger_1 = __importDefault(require("../../src/logger"));
+const database_check_1 = require("../../src/scripts/database-check");
+// The published plugin ships a database client generated for SQLite. Through
+// 2.13.1, `databaseProvider: postgresql` with a SQLite file URL quietly ran on
+// SQLite (Xenon Control profiles did exactly this), and a postgres URL stopped
+// the server with Prisma's "the URL must start with the protocol `file:`" under
+// a hint about adding a column to a table with rows.
+describe('checkDatabase', () => {
+    const sqliteFile = 'file:/Users/me/.cache/xenon/xenon.db';
+    const postgresUrl = 'postgresql://xenon:s3cret@db.example.com:5432/xenon';
+    it('accepts a SQLite file with a SQLite client and says nothing', () => {
+        (0, chai_1.expect)((0, database_check_1.checkDatabase)({ configured: 'sqlite', url: sqliteFile, client: 'sqlite' })).to.deep.equal({});
+    });
+    it('runs a SQLite file on a SQLite client when configured for postgresql, with a warning', () => {
+        const { warning } = (0, database_check_1.checkDatabase)({
+            configured: 'postgresql',
+            url: sqliteFile,
+            client: 'sqlite',
+        });
+        (0, chai_1.expect)(warning).to.be.a('string');
+        (0, chai_1.expect)(warning).to.match(/databaseProvider/);
+        (0, chai_1.expect)(warning).to.match(/SQLite/);
+        (0, chai_1.expect)(warning).to.include('/Users/me/.cache/xenon/xenon.db');
+    });
+    it('refuses a postgres URL when the client is built for SQLite, without printing the password', () => {
+        (0, chai_1.expect)(() => (0, database_check_1.checkDatabase)({ configured: 'postgresql', url: postgresUrl, client: 'sqlite' }))
+            .to.throw(/SQLite/)
+            .with.property('message')
+            .that.does.not.include('s3cret');
+    });
+    it('refuses a postgres URL even when databaseProvider says sqlite', () => {
+        (0, chai_1.expect)(() => (0, database_check_1.checkDatabase)({ configured: 'sqlite', url: postgresUrl, client: 'sqlite' })).to.throw(/db\.example\.com/);
+    });
+    it('accepts a postgres URL when the client was generated for PostgreSQL', () => {
+        (0, chai_1.expect)((0, database_check_1.checkDatabase)({ configured: 'postgresql', url: postgresUrl, client: 'postgresql' })).to.deep.equal({});
+    });
+    it('refuses a SQLite file when the client was generated for PostgreSQL', () => {
+        (0, chai_1.expect)(() => (0, database_check_1.checkDatabase)({ configured: 'postgresql', url: sqliteFile, client: 'postgresql' })).to.throw(/PostgreSQL/);
+    });
+    it('refuses a URL it cannot place', () => {
+        (0, chai_1.expect)(() => (0, database_check_1.checkDatabase)({ configured: 'sqlite', url: 'mysql://h/db', client: 'sqlite' })).to.throw(/mysql:/);
+    });
+});
+describe('clientProviderFromSchema', () => {
+    it("reads the datasource's provider, not the generator's", () => {
+        const schema = [
+            'generator client {',
+            '  provider      = "prisma-client-js"',
+            '}',
+            '',
+            'datasource db {',
+            '  provider = "postgresql"',
+            '  url      = env("DATABASE_URL")',
+            '}',
+        ].join('\n');
+        (0, chai_1.expect)((0, database_check_1.clientProviderFromSchema)(schema)).to.equal('postgresql');
+    });
+    it('returns null when there is no datasource', () => {
+        (0, chai_1.expect)((0, database_check_1.clientProviderFromSchema)('generator client {}')).to.equal(null);
+    });
+});
+describe('describeDatabaseUrl', () => {
+    it('keeps a SQLite path and drops credentials from a server URL', () => {
+        (0, chai_1.expect)((0, database_check_1.describeDatabaseUrl)('file:/data/xenon.db')).to.equal('/data/xenon.db');
+        (0, chai_1.expect)((0, database_check_1.describeDatabaseUrl)('postgresql://u:p@h:5432/db?schema=x')).to.equal('postgresql://h:5432/db');
+    });
+});
+describe('assertSupportedDatabase', () => {
+    let saved;
+    beforeEach(() => {
+        saved = { provider: config_1.config.databaseProvider, url: config_1.config.databaseUrl };
+    });
+    afterEach(() => {
+        config_1.config.databaseProvider = saved.provider;
+        config_1.config.databaseUrl = saved.url;
+        sinon_1.default.restore();
+    });
+    // These read the generated client this repo ships (src/generated/client),
+    // which is built for SQLite.
+    it('stops a server whose URL is a postgres database', () => {
+        config_1.config.databaseProvider = 'postgresql';
+        config_1.config.databaseUrl = 'postgresql://xenon:pw@127.0.0.1:5432/xenon';
+        (0, chai_1.expect)(() => (0, database_check_1.assertSupportedDatabase)()).to.throw(/built for SQLite/);
+    });
+    it('starts a postgresql-labelled server on its SQLite file, and says so once', () => {
+        const warn = sinon_1.default.stub(logger_1.default, 'warn');
+        config_1.config.databaseProvider = 'postgresql';
+        config_1.config.databaseUrl = 'file:/tmp/xenon-check.db';
+        (0, database_check_1.assertSupportedDatabase)();
+        (0, chai_1.expect)(warn.callCount).to.equal(1);
+        (0, chai_1.expect)(String(warn.firstCall.args[0])).to.include('/tmp/xenon-check.db');
+    });
+    it('is silent for the default SQLite setup', () => {
+        const warn = sinon_1.default.stub(logger_1.default, 'warn');
+        config_1.config.databaseProvider = 'sqlite';
+        config_1.config.databaseUrl = 'file:/tmp/xenon-check.db';
+        (0, database_check_1.assertSupportedDatabase)();
+        (0, chai_1.expect)(warn.called).to.equal(false);
+    });
+});

package/lib/test/unit/default-plugin-args.spec.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const schema = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '..', '..', 'schema.json'), 'utf8'));
+/**
+ * Appium fills every default schema.json declares, so a server started the
+ * normal way runs on those. DefaultPluginArgs (the block in
+ * scripts/generate-types-from-schema.js) is the copy the plugin merges under
+ * its options, and used to say 86400000 ms for the health check while the
+ * schema, and so the running server, said 300000. A second copy that can
+ * disagree is how the Settings page came to show a third number.
+ */
+describe('DefaultPluginArgs', () => {
+    it('agrees with every default schema.json declares', () => {
+        const disagreements = Object.entries(schema.properties)
+            .filter(([key, prop]) => 'default' in prop && key in IPluginArgs_1.DefaultPluginArgs)
+            .filter(([key, prop]) => IPluginArgs_1.DefaultPluginArgs[key] !== undefined &&
+            JSON.stringify(IPluginArgs_1.DefaultPluginArgs[key]) !==
+                JSON.stringify(prop.default))
+            .map(([key, prop]) => ({
+            key,
+            schema: prop.default,
+            defaultPluginArgs: IPluginArgs_1.DefaultPluginArgs[key],
+        }));
+        (0, chai_1.expect)(disagreements).to.deep.equal([]);
+    });
+});