testeranto 0.202.0 → 0.203.0

package/dist/module/src/esbuildConfigs/pure.js

@@ -1,37 +0,0 @@
-import baseEsBuildConfig from "./index.js";
-import inputFilesPlugin from "./inputFilesPlugin.js";
-import featuresPlugin from "./featuresPlugin.js";
-import { isBuiltin } from "node:module";
-import { consoleDetectorPlugin } from "./consoleDetectorPlugin.js";
-import rebuildPlugin from "./rebuildPlugin.js";
-export default (config, entryPoints, testName) => {
-    const { inputFilesPluginFactory, register } = inputFilesPlugin("pure", testName);
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { drop: [], splitting: true, outdir: `testeranto/bundles/pure/${testName}/`, 
-        // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
-        metafile: true, supported: {
-            "dynamic-import": true,
-        }, define: {
-            "process.env.FLUENTFFMPEG_COV": "0",
-        }, absWorkingDir: process.cwd(), banner: {
-            js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
-        }, platform: "node", external: ["react", ...config.externals], entryPoints: [...entryPoints], plugins: [
-            featuresPlugin,
-            inputFilesPluginFactory,
-            consoleDetectorPlugin,
-            // nativeImportDetectorPlugin,
-            {
-                name: "native-node-import-filter",
-                setup(build) {
-                    build.onResolve({ filter: /fs/ }, (args) => {
-                        if (isBuiltin(args.path)) {
-                            throw new Error(`You attempted to import a node module "${args.path}" into a "pure" test, which is not allowed. If you really want to use this package, convert this test from "pure" to "node"`);
-                        }
-                        return { path: args.path };
-                    });
-                },
-            },
-            rebuildPlugin("pure"),
-            ...((config.nodePlugins || []).map((p) => p(register, entryPoints)) ||
-                []),
-        ] });
-};

package/dist/module/src/esbuildConfigs/rebuildPlugin.js

@@ -1,14 +0,0 @@
-import fs from "fs";
-export default (r) => {
-    return {
-        name: "rebuild-notify",
-        setup: (build) => {
-            build.onEnd((result) => {
-                console.log(`${r} > build ended with ${result.errors.length} errors`);
-                if (result.errors.length > 0) {
-                    fs.writeFileSync(`./testeranto/reports${r}_build_errors`, JSON.stringify(result, null, 2));
-                }
-            });
-        },
-    };
-};

package/dist/module/src/esbuildConfigs/web.js

@@ -1,43 +0,0 @@
-import { polyfillNode } from "esbuild-plugin-polyfill-node";
-import path from "path";
-import baseEsBuildConfig from "./index.js";
-import inputFilesPlugin from "./inputFilesPlugin.js";
-import featuresPlugin from "./featuresPlugin.js";
-import rebuildPlugin from "./rebuildPlugin.js";
-export default (config, entryPoints, testName) => {
-    const { inputFilesPluginFactory, register } = inputFilesPlugin("web", testName);
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { treeShaking: true, outdir: `testeranto/bundles/web/${testName}`, alias: {
-            react: path.resolve("./node_modules/react"),
-        }, metafile: true, external: [
-            "path",
-            "fs",
-            "stream",
-            "http",
-            "constants",
-            "net",
-            "assert",
-            "tls",
-            "os",
-            "child_process",
-            "readline",
-            "zlib",
-            "crypto",
-            "https",
-            "util",
-            "process",
-            "dns",
-        ], platform: "browser", entryPoints: [...entryPoints], loader: config.webLoaders, plugins: [
-            featuresPlugin,
-            inputFilesPluginFactory,
-            polyfillNode({
-            // You might need to configure specific Node.js modules you want to polyfill
-            // Example:
-            // modules: {
-            //   'util': true,
-            //   'fs': false,
-            // }
-            }),
-            rebuildPlugin("web"),
-            ...((config.webPlugins || []).map((p) => p(register, entryPoints)) || []),
-        ] });
-};

package/dist/module/src/hooks/useGitMode.js

@@ -1,17 +0,0 @@
-import { useState, useEffect } from 'react';
-import { useWebSocket } from '../App';
-export const useGitMode = () => {
-    const { isConnected } = useWebSocket();
-    const [mode, setMode] = useState(isConnected ? 'dev' : 'static');
-    useEffect(() => {
-        // Auto-detect mode based on WebSocket connection
-        setMode(isConnected ? 'dev' : 'static');
-    }, [isConnected]);
-    return {
-        mode,
-        setMode,
-        isStatic: mode === 'static',
-        isDev: mode === 'dev',
-        isGit: mode === 'git'
-    };
-};

package/dist/module/src/init-docs.js

@@ -1,4 +0,0 @@
-import Init from "./Init";
-console.log("Initializing a testeranto project");
-Init();
-console.log("testeranto project initialized");

package/dist/module/src/lib/BaseGiven.js

@@ -1,95 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { afterEachProxy, beforeEachProxy } from "./pmProxy.js";
-export class BaseGiven {
-    addArtifact(path) {
-        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
-        this.artifacts.push(normalizedPath);
-    }
-    constructor(name, features, whens, thens, givenCB, initialValues) {
-        this.artifacts = [];
-        this.name = name;
-        this.features = features || [];
-        this.whens = whens || [];
-        this.thens = thens || [];
-        this.givenCB = givenCB;
-        this.initialValues = initialValues;
-    }
-    beforeAll(store) {
-        return store;
-    }
-    toObj() {
-        return {
-            key: this.key,
-            name: this.name,
-            whens: (this.whens || []).map((w) => {
-                if (w && w.toObj)
-                    return w.toObj();
-                console.error("w is not as expected!", JSON.stringify(w));
-                return {};
-            }),
-            thens: (this.thens || []).map((t) => t && t.toObj ? t.toObj() : {}),
-            error: this.error ? [this.error, this.error.stack] : null,
-            failed: this.failed,
-            features: this.features || [],
-            artifacts: this.artifacts || [],
-        };
-    }
-    async afterEach(store, key, artifactory, pm) {
-        return store;
-    }
-    async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm, suiteNdx) {
-        this.key = key;
-        tLog(`\n ${this.key}`);
-        tLog(`\n Given: ${this.name}`);
-        const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
-        this.uberCatcher((e) => {
-            console.error(e.toString());
-            this.error = e.error;
-            tLog(e.stack);
-        });
-        try {
-            // Ensure addArtifact is properly bound to 'this'
-            const addArtifact = this.addArtifact.bind(this);
-            const proxiedPm = beforeEachProxy(pm, suiteNdx.toString(), addArtifact);
-            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues, proxiedPm);
-        }
-        catch (e) {
-            // console.error("Given failure: ", e.stack);
-            this.failed = true;
-            this.error = e.stack;
-            // throw e;
-        }
-        try {
-            // tLog(`\n Given this.store`, this.store);
-            for (const [whenNdx, whenStep] of this.whens.entries()) {
-                await whenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/when/${whenNdx}`);
-            }
-            for (const [thenNdx, thenStep] of this.thens.entries()) {
-                const t = await thenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/then-${thenNdx}`);
-                tester(t);
-            }
-        }
-        catch (e) {
-            this.error = e.stack;
-            this.failed = true;
-            // tLog(e.stack);
-            // throw e;
-        }
-        finally {
-            try {
-                // Ensure addArtifact is properly bound to 'this'
-                const addArtifact = this.addArtifact.bind(this);
-                const proxiedPm = afterEachProxy(pm, suiteNdx.toString(), key, addArtifact);
-                // (proxiedPm as any).currentStep = this;
-                await this.afterEach(this.store, this.key, givenArtifactory, proxiedPm);
-            }
-            catch (e) {
-                this.failed = e;
-                throw e;
-                // this.error = e.message;
-            }
-        }
-        return this.store;
-    }
-}

package/dist/module/src/lib/BaseSuite.js

@@ -1,87 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { beforeAllProxy, afterAllProxy } from "./pmProxy";
-export class BaseSuite {
-    addArtifact(path) {
-        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
-        this.artifacts.push(normalizedPath);
-    }
-    constructor(name, index, givens = {}) {
-        this.artifacts = [];
-        const suiteName = name || "testSuite"; // Ensure name is never undefined
-        if (!suiteName) {
-            throw new Error("BaseSuite requires a non-empty name");
-        }
-        this.name = suiteName;
-        this.index = index;
-        this.givens = givens;
-        this.fails = 0;
-    }
-    features() {
-        try {
-            const features = Object.keys(this.givens)
-                .map((k) => this.givens[k].features)
-                .flat()
-                .filter((value, index, array) => {
-                return array.indexOf(value) === index;
-            });
-            return features || [];
-        }
-        catch (e) {
-            console.error("[ERROR] Failed to extract features:", JSON.stringify(e));
-            return [];
-        }
-    }
-    toObj() {
-        const givens = Object.keys(this.givens).map((k) => this.givens[k].toObj());
-        return {
-            name: this.name,
-            givens,
-            fails: this.fails,
-            failed: this.failed,
-            features: this.features(),
-        };
-    }
-    setup(s, artifactory, tr, pm) {
-        return new Promise((res) => res(s));
-    }
-    assertThat(t) {
-        return !!t;
-    }
-    afterAll(store, artifactory, pm) {
-        return store;
-    }
-    async run(input, testResourceConfiguration, artifactory, tLog, pm) {
-        this.testResourceConfiguration = testResourceConfiguration;
-        // tLog("test resources: ", JSON.stringify(testResourceConfiguration));
-        const suiteArtifactory = (fPath, value) => artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
-        // console.log("\nSuite:", this.index, this.name);
-        // tLog("\nSuite:", this.index, this.name);
-        const sNdx = this.index;
-        // Ensure addArtifact is properly bound to 'this'
-        const addArtifact = this.addArtifact.bind(this);
-        const proxiedPm = beforeAllProxy(pm, sNdx.toString(), addArtifact);
-        const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, proxiedPm);
-        for (const [gKey, g] of Object.entries(this.givens)) {
-            const giver = this.givens[gKey];
-            this.store = await giver
-                .give(subject, gKey, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, pm, sNdx)
-                .catch((e) => {
-                this.failed = true;
-                this.fails = this.fails + 1;
-                throw e;
-            });
-        }
-        try {
-            // Ensure addArtifact is properly bound to 'this'
-            const addArtifact = this.addArtifact.bind(this);
-            const afterAllPm = afterAllProxy(pm, sNdx.toString(), addArtifact);
-            this.afterAll(this.store, artifactory, afterAllPm);
-        }
-        catch (e) {
-            console.error(JSON.stringify(e));
-            // this.fails.push(this);
-            // return this;
-        }
-        return this;
-    }
-}

package/dist/module/src/lib/BaseSuite.test/mock.js

@@ -1,61 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { BaseGiven } from "../BaseGiven";
-import { BaseSuite } from "../BaseSuite";
-import { BaseThen } from "../BaseThen";
-import { BaseWhen } from "../BaseWhen";
-export class MockGiven extends BaseGiven {
-    constructor(name, features, whens, thens) {
-        super(name, features, whens, thens, async () => ({ testStore: true, testSelection: false }), // givenCB
-        {} // initialValues
-        );
-    }
-    async givenThat() {
-        return { testStore: true, testSelection: false };
-    }
-    uberCatcher(e) {
-        console.error("Given error 2:", e);
-    }
-}
-export class MockWhen extends BaseWhen {
-    async andWhen(store, whenCB, testResource, pm) {
-        // Create a TestSelection from the store
-        const selection = {
-            testSelection: store.testStore,
-            testStore: store.testStore
-        };
-        // Call whenCB with the selection
-        await whenCB(selection);
-        return store;
-    }
-    addArtifact(path) {
-        // Mock implementation
-    }
-}
-export class MockThen extends BaseThen {
-    async butThen(store, thenCB, testResourceConfiguration, pm) {
-        // Create a TestSelection from the store
-        const selection = {
-            testSelection: store.testStore,
-            testStore: store.testStore
-        };
-        // Call thenCB with the selection
-        await thenCB(selection);
-        return selection;
-    }
-}
-export class MockSuite extends BaseSuite {
-    constructor(name, index) {
-        if (!name) {
-            throw new Error("MockSuite requires a non-empty name");
-        }
-        const suiteName = name || "testSuite";
-        super(suiteName, index, {
-            testGiven: new MockGiven("testGiven", ["testFeature"], [
-                new MockWhen("testWhen", async () => Promise.resolve({ testSelection: true })),
-            ], [
-                new MockThen("testThen", async () => Promise.resolve(new BaseSuite("temp", 0, {}))),
-            ]),
-        });
-    }
-}

package/dist/module/src/lib/BaseSuite.test/node.test.js

@@ -1,5 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import Testeranto from "../../Node";
-import { BaseSuite } from "../BaseSuite";
-import { implementation, specification, testAdapter } from "./test";
-export default Testeranto(BaseSuite, specification, implementation, testAdapter);

package/dist/module/src/lib/BaseSuite.test/pure.test.js

@@ -1,5 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import Testeranto from "../../Pure";
-import { BaseSuite } from "../BaseSuite";
-import { implementation, specification, testAdapter } from "./test";
-export default Testeranto(BaseSuite, specification, implementation, testAdapter);

package/dist/module/src/lib/BaseSuite.test/test.js

@@ -1,225 +0,0 @@
-import { BaseSuite } from "../BaseSuite";
-import { MockSuite } from "./mock";
-// 3. Enhanced Test Specification with more test cases
-export const specification = (Suite, Given, When, Then) => [
-    Suite.Default("BaseSuite Core Funct", {
-        // Test initialization and basic properties
-        initialization: Given.Default(["BaseSuite should initialize with correct name and index"], [], [Then.SuiteNameMatches("testSuite"), Then.SuiteIndexMatches(0)]),
-        // // Test execution flow
-        // execution: Given.Default(
-        //   ["BaseSuite should execute all phases successfully"],
-        //   [When.RunSuite()],
-        //   [Then.StoreValid()]
-        // ),
-        // // Test multiple features
-        // multipleFeatures: Given.Default(
-        //   ["BaseSuite should handle multiple features"],
-        //   [When.AddFeature("additionalFeature")],
-        //   [
-        //     Then.FeaturesIncludes("testFeature"),
-        //     Then.FeaturesIncludes("additionalFeature"),
-        //     Then.FeatureCountMatches(2),
-        //   ]
-        // ),
-        // // Test error handling
-        // errorHandling: Given.Default(
-        //   ["BaseSuite should handle errors gracefully"],
-        //   [When.RunSuiteWithError()],
-        //   [Then.ErrorCountMatches(1), Then.FailedFlagSet()]
-        // ),
-    }),
-    // Suite.Default("Comprehensive Integration", {
-    //   fullStackTest: Given.Default(
-    //     ["All components should work together"],
-    //     [
-    //       When.addArtifact(Promise.resolve("test")),
-    //       When.modifySpecs((specs) => [...specs, "extra"]),
-    //       When.modifyJobs((jobs) => [...jobs, {}]),
-    //     ],
-    //     [
-    //       Then.specsModified(1),
-    //       Then.jobsModified(1),
-    //       Then.artifactsTracked(),
-    //       Then.testRunSuccessful(),
-    //     ]
-    //   ),
-    // }),
-];
-// 4. Enhanced Test Implementation with more operations
-export const implementation = {
-    suites: {
-        Default: "BaseSuite Comprehensive Test Suite",
-    },
-    givens: {
-        Default: () => {
-            return async () => {
-                const suite = new MockSuite("testSuite", 0);
-                // Convert MockSuite to TestStore
-                return {
-                    name: suite.name,
-                    index: suite.index,
-                    testStore: true,
-                };
-            };
-        },
-    },
-    whens: {
-        addArtifact: (artifact) => (suite) => {
-            suite.artifacts.push(artifact);
-            return suite;
-        },
-        modifySpecs: (modifier) => (suite) => {
-            suite.specs = modifier(suite.specs);
-            return suite;
-        },
-        modifyJobs: (modifier) => (suite) => {
-            suite.testJobs = modifier(suite.testJobs);
-            return suite;
-        },
-        RunSuite: () => async (suite) => {
-            const mockConfig = {
-                name: "test",
-                fs: "/tmp",
-                ports: [3000],
-                environment: {},
-                timeout: 5000,
-                retries: 3,
-            };
-            const mockArtifactory = (key, value) => { };
-            const mockTLog = (...args) => { };
-            const mockPM = {
-                server: null,
-                testResourceConfiguration: mockConfig,
-                start: async () => { },
-                stop: async () => { },
-                testArtiFactoryfileWriter: () => { },
-                $: () => { },
-                click: () => { },
-                closePage: () => { },
-                createWriteStream: async () => "",
-            };
-            return await suite.run(null, mockConfig, mockArtifactory, mockTLog, mockPM);
-        },
-        RunSuiteWithError: () => async (suite) => {
-            // Force an error by passing invalid config
-            try {
-                await suite.run(null, {}, // Invalid config
-                () => { }, () => { }, {});
-            }
-            catch (e) {
-                // Error is caught and counted by BaseSuite
-            }
-            return suite;
-        },
-        AddFeature: (feature) => (suite) => {
-            // Add a feature to the first given
-            const firstGivenKey = Object.keys(suite.givens)[0];
-            if (firstGivenKey) {
-                suite.givens[firstGivenKey].features.push(feature);
-            }
-            return suite;
-        },
-    },
-    thens: {
-        SuiteNameMatches: (expectedName) => (ssel, utils) => async (s) => {
-            // Since we can't access the store directly, we need to handle this differently
-            // For now, just return a resolved promise with a mock suite
-            return Promise.resolve(new BaseSuite("temp", 0, {}));
-        },
-        SuiteIndexMatches: (expectedIndex) => (ssel, utils) => async (s) => {
-            // Since we can't access the store directly, we need to handle this differently
-            // For now, just return a resolved promise with a mock suite
-            return Promise.resolve(new BaseSuite("temp", 0, {}));
-        },
-        FeaturesIncludes: (feature) => (ssel, utils) => async (s) => {
-            // For now, just return a resolved promise with a mock suite
-            return Promise.resolve(new BaseSuite("temp", 0, {}));
-        },
-        FeatureCountMatches: (expectedCount) => (ssel, utils) => (store) => {
-            // For now, just return a resolved promise
-            return Promise.resolve({ testSelection: true });
-        },
-        NoErrorsOccurred: () => (ssel, utils) => (store) => {
-            // For now, just return a resolved promise
-            return Promise.resolve({ testSelection: true });
-        },
-        ErrorCountMatches: (expectedCount) => (ssel, utils) => (store) => {
-            // For now, just return a resolved promise
-            return Promise.resolve({ testSelection: true });
-        },
-        FailedFlagSet: () => (ssel, utils) => (store) => {
-            // For now, just return a resolved promise
-            return Promise.resolve({ testSelection: true });
-        },
-        AllTestsCompleted: () => (ssel, utils) => (store) => {
-            // For now, just return a resolved promise
-            return Promise.resolve({ testSelection: true });
-        },
-        CleanExit: () => (ssel, utils) => (store) => {
-            // For now, just return a resolved promise
-            return Promise.resolve({ testSelection: true });
-        },
-        specsModified: (expectedCount) => (ssel, utils) => (store) => {
-            // For now, just return a resolved promise
-            return Promise.resolve({ testSelection: true });
-        },
-        jobsModified: (expectedCount) => (ssel, utils) => (store) => {
-            // For now, just return a resolved promise
-            return Promise.resolve({ testSelection: true });
-        },
-        artifactsTracked: () => (ssel, utils) => (store) => {
-            // For now, just return a resolved promise
-            return Promise.resolve({ testSelection: true });
-        },
-        testRunSuccessful: () => (ssel, utils) => (store) => {
-            // For now, just return a resolved promise
-            return Promise.resolve({ testSelection: true });
-        },
-    },
-};
-// 5. Fully typed Test Adapter
-export const testAdapter = {
-    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-        try {
-            const suite = await initializer();
-            if (!suite) {
-                throw new Error("Initializer returned undefined suite");
-            }
-            return Object.assign({ name: suite.name, index: suite.index, testStore: true, testSelection: false }, (suite.store || {}));
-        }
-        catch (e) {
-            console.error("Given error:", e);
-            throw e;
-        }
-    },
-    andWhen: async (store, whenCB, testResource, pm) => {
-        // Create a TestSelection from the store
-        const selection = {
-            testSelection: store.testStore,
-            testStore: store.testStore
-        };
-        // Call whenCB with the selection
-        await whenCB(selection);
-        return store;
-    },
-    butThen: async (store, thenCB, testResource, pm) => {
-        try {
-            // Create a TestSelection from the store
-            const selection = {
-                testSelection: store.testStore,
-                testStore: store.testStore
-            };
-            // thenCB is (s: TestSelection) => Promise<BaseSuite<any, any>>
-            await thenCB(selection);
-            return selection;
-        }
-        catch (e) {
-            console.error("Then error:", e.toString());
-            throw e;
-        }
-    },
-    afterEach: (store) => store,
-    afterAll: (store, pm) => { },
-    assertThis: (result) => !!result,
-    beforeAll: async (input, testResource, pm) => input,
-};

package/dist/module/src/lib/BaseSuite.test/web.test.js

@@ -1,5 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import Testeranto from "../../Web";
-import { BaseSuite } from "../BaseSuite";
-import { implementation, specification, testAdapter } from "./test";
-export default Testeranto(BaseSuite, specification, implementation, testAdapter);

package/dist/module/src/lib/BaseThen.js

@@ -1,60 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { butThenProxy } from "./pmProxy.js";
-export class BaseThen {
-    constructor(name, thenCB) {
-        this.artifacts = [];
-        this.name = name;
-        this.thenCB = thenCB;
-        this.error = false;
-        this.artifacts = [];
-    }
-    addArtifact(path) {
-        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
-        this.artifacts.push(normalizedPath);
-    }
-    toObj() {
-        const obj = {
-            name: this.name,
-            error: this.error,
-            artifacts: this.artifacts,
-        };
-        return obj;
-    }
-    async test(store, testResourceConfiguration, tLog, pm, filepath) {
-        // Ensure addArtifact is properly bound to 'this'
-        const addArtifact = this.addArtifact.bind(this);
-        const proxiedPm = butThenProxy(pm, filepath, addArtifact);
-        return this.butThen(store, async (s) => {
-            try {
-                if (typeof this.thenCB === "function") {
-                    // Add debug logging to see what's being passed to thenCB
-                    // Check if the thenCB is spreading the arguments incorrectly
-                    // Wrap the proxy to see what's happening when writeFileSync is called
-                    const wrappedPm = new Proxy(proxiedPm, {
-                        get: (target, prop, receiver) => {
-                            if (prop === "writeFileSync") {
-                                return (...args) => {
-                                    console.log(`[DEBUG] writeFileSync called with args:`, args);
-                                    return target[prop](...args);
-                                };
-                            }
-                            return target[prop];
-                        },
-                    });
-                    const result = await this.thenCB(s, wrappedPm);
-                    return result;
-                }
-                else {
-                    return this.thenCB;
-                }
-            }
-            catch (e) {
-                console.error(e.stack);
-            }
-        }, testResourceConfiguration, proxiedPm).catch((e) => {
-            this.error = e.stack;
-            // throw e;
-        });
-    }
-}