@digicatapult/sqnc-process-management 2.2.130 → 2.2.132

package/build/tests/integration/command-functions.test.js

@@ -1,414 +0,0 @@
-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 __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { expect } from 'chai';
-import { createProcess, disableProcess, loadProcesses } from '../../src/lib/process/index.js';
-import { validAllRestrictions, invalidPOSIX, multiple, simple2, simple, invalidRestrictionKey, invalidRestrictionValue, } from '../fixtures/programs.js';
-import { Constants } from '../../src/lib/process/constants.js';
-import { getVersionHelper } from '../helpers/substrateHelper.js';
-import { ZodError } from 'zod';
-import { DisableError, ProgramError, VersionError } from '../../src/lib/types/error.js';
-import { getAll } from '../../src/lib/process/api.js';
-/* fixtures */
-import processesExample from '../fixtures/processes.js';
-import { withSubstrateNode } from '../helpers/containers.js';
-import { createNodeApi } from '../../src/lib/utils/polkadot.js';
-const createProcessAndWait = (processRaw, options, dryRun, verbose) => __awaiter(void 0, void 0, void 0, function* () {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        const polkadot = __addDisposableResource(env_1, yield createNodeApi(options), true);
-        const { waitForFinalised } = yield createProcess(processRaw, dryRun, polkadot, options, verbose);
-        const result = yield waitForFinalised;
-        return result;
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        const result_1 = __disposeResources(env_1);
-        if (result_1)
-            yield result_1;
-    }
-});
-describe('Process creation and deletion, listing', () => {
-    const context = {
-        polkadotOptions: { API_HOST: 'localhost', API_PORT: 0, USER_URI: '//Alice', MANUAL_SEAL: true },
-    };
-    withSubstrateNode({ manualSeal: true }, context);
-    describe('Happy path', () => {
-        describe('Multiple processes', () => {
-            it('skips already created processes and creates new ones', () => __awaiter(void 0, void 0, void 0, function* () {
-                yield createProcessAndWait({
-                    name: 'existing-process-test',
-                    version: 1,
-                    program: simple2,
-                }, context.polkadotOptions, false);
-                const process2Name = 'process-to-be-created';
-                const process2BumpedV = (yield getVersionHelper(process2Name, context.polkadotOptions)) + 1;
-                const newProcesses = yield loadProcesses({
-                    options: context.polkadotOptions,
-                    data: multiple('existing-process-test', 1, process2Name, process2BumpedV),
-                });
-                if (newProcesses.type !== 'ok') {
-                    expect.fail('Expected new process creation to succeed');
-                }
-                expect(newProcesses.result['existing-process-test'].type).to.equal('ok');
-                expect(newProcesses.result['existing-process-test']).to.deep.contain({
-                    message: 'Skipping: process existing-process-test is already created.',
-                    result: {
-                        name: 'existing-process-test',
-                        version: 1,
-                        status: 'Enabled',
-                    },
-                });
-                const process2Result = newProcesses.result[process2Name];
-                if (process2Result.type !== 'ok') {
-                    expect.fail('Expected process create for process2 to succeed');
-                }
-                expect(process2Result.message).to.deep.equal('Transaction for new process process-to-be-created has been successfully submitted');
-                expect(process2Result.result).to.deep.contain({
-                    version: process2BumpedV,
-                    status: 'Enabled',
-                });
-            }));
-            it('creates multiple processes', () => __awaiter(void 0, void 0, void 0, function* () {
-                const process1Name = 'process-1';
-                const process1BumpedV = (yield getVersionHelper(process1Name, context.polkadotOptions)) + 1;
-                const process2Name = 'process-2';
-                const process2BumpedV = (yield getVersionHelper(process2Name, context.polkadotOptions)) + 1;
-                const newProcesses = yield loadProcesses({
-                    options: context.polkadotOptions,
-                    data: multiple(process1Name, process1BumpedV, process2Name, process2BumpedV),
-                });
-                if (newProcesses.type !== 'ok') {
-                    expect.fail('Expected new process creation to succeed');
-                }
-                expect(newProcesses.result[process1Name].message).to.deep.equal('Transaction for new process process-1 has been successfully submitted');
-                const process1Result = newProcesses.result[process1Name];
-                if (process1Result.type !== 'ok') {
-                    expect.fail('Expected process1 creation to succeed');
-                }
-                expect(process1Result.result).to.deep.contain({
-                    version: process1BumpedV,
-                    status: 'Enabled',
-                });
-                const process2Result = newProcesses.result[process2Name];
-                if (process2Result.type !== 'ok') {
-                    expect.fail('Expected process2 creation to succeed');
-                }
-                expect(process2Result.message).to.deep.equal('Transaction for new process process-2 has been successfully submitted');
-                expect(process2Result.result).to.deep.contain({
-                    version: process2BumpedV,
-                    status: 'Enabled',
-                });
-            }));
-            it('loads and skips multiple processes using number values', () => __awaiter(void 0, void 0, void 0, function* () {
-                yield loadProcesses({ options: context.polkadotOptions, data: JSON.stringify(processesExample) });
-                const res = yield loadProcesses({ options: context.polkadotOptions, data: JSON.stringify(processesExample) });
-                if (res.type !== 'ok') {
-                    expect.fail('Expected process create to succeed');
-                }
-                const process1Result = res.result['test-program-create'];
-                const process2Result = res.result['test-program-propose'];
-                const process3Result = res.result['test-program-strings-and-numbers'];
-                if (process1Result.type !== 'ok') {
-                    expect.fail('Expected test-program-create to be already created and succeed');
-                }
-                if (process2Result.type !== 'ok') {
-                    expect.fail('Expected test-program-propose to be already created and succeed');
-                }
-                if (process2Result.type !== 'ok') {
-                    expect.fail('Expected test-program-strings-and-numbers to be already created and succeed');
-                }
-                expect(process1Result.message).to.equal('Skipping: process test-program-create is already created.');
-                expect(process2Result.message).to.equal('Skipping: process test-program-propose is already created.');
-                expect(process3Result.message).to.equal('Skipping: process test-program-strings-and-numbers is already created.');
-            })).timeout(60000);
-        });
-        it('creates then disables a process', () => __awaiter(void 0, void 0, void 0, function* () {
-            const processName = '0';
-            const currentVersion = yield getVersionHelper(processName, context.polkadotOptions);
-            const bumpedVersion = currentVersion + 1;
-            const newProcess = yield createProcessAndWait({ name: processName, version: bumpedVersion, program: simple }, context.polkadotOptions, false);
-            if (newProcess.type !== 'ok') {
-                expect.fail('Expected process creation to succeed');
-            }
-            expect(newProcess.result).to.deep.equal({
-                name: processName,
-                version: bumpedVersion,
-                status: 'Enabled',
-            });
-            const disabledProcess = yield disableProcess(processName, bumpedVersion, false, context.polkadotOptions);
-            if (disabledProcess.type !== 'ok') {
-                expect.fail('Expected process disable to succeed');
-            }
-            expect(disabledProcess.message).to.equal('Process has been disabled');
-            expect(disabledProcess.result).to.deep.equal({
-                name: processName,
-                version: bumpedVersion,
-                status: 'Disabled',
-            });
-        }));
-        it('does not create process if dry run', () => __awaiter(void 0, void 0, void 0, function* () {
-            const processName = '0';
-            const currentVersion = yield getVersionHelper(processName, context.polkadotOptions);
-            const bumpedVersion = currentVersion + 1;
-            const newProcess = yield createProcessAndWait({ name: processName, version: bumpedVersion, program: validAllRestrictions }, context.polkadotOptions, true);
-            if (newProcess.type !== 'ok') {
-                expect.fail('Expected process create to succeed');
-            }
-            expect(newProcess.message).to.equal('Dry run: transaction has not been created');
-            expect(newProcess.result).to.deep.equal({
-                name: processName,
-                version: bumpedVersion,
-                status: 'Enabled (dry-run)',
-            });
-        }));
-        it('does not disable process if dry run', () => __awaiter(void 0, void 0, void 0, function* () {
-            const processName = '0';
-            const currentVersion = yield getVersionHelper(processName, context.polkadotOptions);
-            const bumpedVersion = currentVersion + 1;
-            const newProcess = yield createProcessAndWait({ name: processName, version: bumpedVersion, program: validAllRestrictions }, context.polkadotOptions, false);
-            expect(newProcess.type).to.equal('ok');
-            const disabledProcess = yield disableProcess(processName, bumpedVersion, true, context.polkadotOptions);
-            if (disabledProcess.type !== 'ok') {
-                expect.fail('Expected disable process to succeed');
-            }
-            expect(disabledProcess.result).to.deep.contain({
-                name: processName,
-                status: 'Disabled (dry-run)',
-            });
-            expect(disabledProcess).to.deep.contain({
-                message: `This will DISABLE the following process ${processName}`,
-            });
-        }));
-        // it('returns a list of raw processes when with --verbose flag', () => {
-        it('returns a list of processes', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield getAll(context.polkadotOptions);
-            expect(res).to.be.an('array');
-            expect(res[0])
-                .to.be.an('object')
-                .that.has.keys(['name', 'createdAtHash', 'initialU8aLength', 'program', 'status', 'version']);
-        }));
-    });
-    describe('Sad path', () => {
-        const validProcessName = '0';
-        let validVersionNumber;
-        before(() => __awaiter(void 0, void 0, void 0, function* () {
-            const currentVersion = yield getVersionHelper(validProcessName, context.polkadotOptions);
-            validVersionNumber = currentVersion + 1;
-        }));
-        describe('If process already exists', () => {
-            describe('Multiple uploads', () => {
-                // TODO could prestage in before if more scenarios
-                it('skips and notifies if process programs are different', () => __awaiter(void 0, void 0, void 0, function* () {
-                    yield createProcessAndWait({ name: 'existing-length', version: 1, program: validAllRestrictions }, context.polkadotOptions, false);
-                    const process2Name = 'should-create-1';
-                    const process2BumpedV = (yield getVersionHelper(process2Name, context.polkadotOptions)) + 1;
-                    const res = yield loadProcesses({
-                        options: context.polkadotOptions,
-                        data: multiple('existing-length', 1, process2Name, process2BumpedV),
-                    });
-                    if (res.type !== 'ok') {
-                        expect.fail('Expected overall create to succeed');
-                    }
-                    const failResult = res.result['existing-length'];
-                    if (failResult.type !== 'error') {
-                        expect.fail('Expected existing-length creation to fail');
-                    }
-                    expect(failResult.message).to.equal('existing: programs are different lengths');
-                    const process2Res = res.result[process2Name];
-                    if (process2Res.type !== 'ok') {
-                        expect.fail(`Expected ${process2Name} creation to succeed`);
-                    }
-                    expect(process2Res.message).to.equal('Transaction for new process should-create-1 has been successfully submitted');
-                }));
-                it('also fails if number of steps matches but POSTFIX does not', () => __awaiter(void 0, void 0, void 0, function* () {
-                    yield createProcessAndWait({ name: 'existing-steps', version: 1, program: simple }, context.polkadotOptions, false);
-                    const process2Name = 'should-create-2';
-                    const process2BumpedV = (yield getVersionHelper(process2Name, context.polkadotOptions)) + 1;
-                    const res = yield loadProcesses({
-                        options: context.polkadotOptions,
-                        data: multiple('existing-steps', 1, process2Name, process2BumpedV),
-                    });
-                    // TODO: should this fail
-                    if (res.type !== 'ok') {
-                        expect.fail('Expected overall process create to succeed');
-                    }
-                    expect(res.result['existing-steps'].message).to.equal('existing: program steps did not match');
-                    expect(res.result[process2Name].message).to.equal('Transaction for new process should-create-2 has been successfully submitted');
-                }));
-            });
-            it('does not create new one and notifies if programs are different length', () => __awaiter(void 0, void 0, void 0, function* () {
-                yield createProcessAndWait({ name: 'existing-single', version: 1, program: validAllRestrictions }, context.polkadotOptions, false);
-                const res = yield createProcessAndWait({ name: 'existing-single', version: 1, program: simple }, context.polkadotOptions, false);
-                if (res.type !== 'error') {
-                    expect.fail('Expected program create with different lengths to fail');
-                }
-                expect(res.message).to.equal('existing: programs are different lengths');
-                expect(res.error).to.instanceOf(ProgramError);
-            }));
-            it('does not create new one and notifies if programs same are length but do not match', () => __awaiter(void 0, void 0, void 0, function* () {
-                yield createProcessAndWait({ name: 'existing-steps-single', version: 1, program: simple2 }, context.polkadotOptions, false);
-                const res = yield createProcessAndWait({ name: 'existing-steps-single', version: 1, program: [{ Restriction: 'None' }] }, context.polkadotOptions, false);
-                if (res.type !== 'error') {
-                    expect.fail('Expected program create with different lengths to fail');
-                }
-                expect(res.message).to.equal('existing: program steps did not match');
-                expect(res.error).to.instanceOf(ProgramError);
-                const error = res.error;
-                expect(error.process).to.deep.contain({
-                    name: 'existing-steps-single',
-                    version: 1,
-                    status: 'Enabled',
-                });
-            }));
-        });
-        it('fails for invalid POSTFIX notation', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: invalidPOSIX }, context.polkadotOptions, false);
-            if (res.type !== 'error') {
-                expect.fail('Expected process create to fail');
-            }
-            expect(res.error).to.be.instanceOf(ProgramError);
-            expect(res.message).to.equal('invalid program');
-        }));
-        it('fails for invalid restriction key', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield createProcessAndWait({
-                name: validProcessName,
-                version: validVersionNumber,
-                program: invalidRestrictionKey,
-            }, context.polkadotOptions, false);
-            if (res.type !== 'error') {
-                expect.fail('Expected process create to fail');
-            }
-            expect(res.error).to.be.instanceOf(ZodError);
-            const zError = res.error;
-            expect(zError.issues[0]).to.deep.contain({
-                code: 'invalid_union',
-                message: 'Invalid input',
-            });
-        }));
-        it('fails for invalid restriction value', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: invalidRestrictionValue }, context.polkadotOptions, false);
-            if (res.type !== 'error') {
-                expect.fail('Expected process create to fail');
-            }
-            expect(res.error).to.be.instanceOf(ZodError);
-        }));
-        it('fails for invalid json', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: 'invalidJson' }, context.polkadotOptions, false);
-            if (res.type !== 'error') {
-                expect.fail('Expected process create to fail');
-            }
-            expect(res.error).to.be.instanceOf(ZodError);
-        }));
-        it('fails to create for too low version', () => __awaiter(void 0, void 0, void 0, function* () {
-            // - 2 because -1 would make current = valid
-            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber - 2, program: validAllRestrictions }, context.polkadotOptions, false);
-            if (res.type !== 'error') {
-                expect.fail('Expected process create to fail');
-            }
-            expect(res.message).to.equal(`Process version ${validVersionNumber - 2} is invalid. If you are trying to create a new version of process ${validProcessName} version should be ${validVersionNumber}`);
-            expect(res.error).to.be.instanceOf(VersionError);
-        }));
-        it('fails to create for too high version', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber + 1, program: validAllRestrictions }, context.polkadotOptions, false);
-            if (res.type !== 'error') {
-                expect.fail('Expected process create to fail');
-            }
-            expect(res.message).to.equal(`Process version ${validVersionNumber + 1} is invalid. If you are trying to create a new version of process ${validProcessName} version should be ${validVersionNumber}`);
-            expect(res.error).to.be.instanceOf(VersionError);
-        }));
-        it('fails to create with too long process id', () => __awaiter(void 0, void 0, void 0, function* () {
-            const processName = '0'.repeat(Constants.PROCESS_ID_LENGTH + 1);
-            const res = yield createProcessAndWait({ name: processName, version: 1, program: validAllRestrictions }, context.polkadotOptions, false);
-            if (res.type !== 'error') {
-                expect.fail('Expected process create to fail');
-            }
-            expect(res.error).to.be.instanceOf(ZodError);
-        }));
-        it('fails to disable process that does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
-            let err = null;
-            try {
-                yield disableProcess('incorrectProcessName', 1, false, context.polkadotOptions);
-            }
-            catch (error) {
-                err = error;
-            }
-            expect(err).instanceOf(DisableError);
-        }));
-        it('fails to disable process a second time', () => __awaiter(void 0, void 0, void 0, function* () {
-            const newProcess = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: simple }, context.polkadotOptions, false);
-            expect(newProcess.type).to.equal('ok');
-            const firstDisable = yield disableProcess(validProcessName, validVersionNumber, false, context.polkadotOptions);
-            expect(firstDisable.type).to.equal('ok');
-            let err = null;
-            try {
-                yield disableProcess(validProcessName, validVersionNumber, false, context.polkadotOptions);
-            }
-            catch (error) {
-                err = error;
-            }
-            expect(err).instanceOf(DisableError);
-        }));
-    });
-});

package/build/tests/integration/without-manual-seal.test.d.ts

@@ -1 +0,0 @@
-export {};

package/build/tests/integration/without-manual-seal.test.js

@@ -1,52 +0,0 @@
-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());
-    });
-};
-import { expect } from 'chai';
-import { loadProcesses } from '../../src/lib/process/index.js';
-import { multiple } from '../fixtures/programs.js';
-import { getVersionHelper } from '../helpers/substrateHelper.js';
-import { withSubstrateNode } from '../helpers/containers.js';
-describe('Transactions without manual seal', function () {
-    this.timeout(60000);
-    const context = {
-        polkadotOptions: { API_HOST: 'localhost', API_PORT: 0, USER_URI: '//Alice', MANUAL_SEAL: false },
-    };
-    withSubstrateNode({ manualSeal: false }, context);
-    it('creates multiple processes', () => __awaiter(this, void 0, void 0, function* () {
-        const process1Name = 'process-1';
-        const process1BumpedV = (yield getVersionHelper(process1Name, context.polkadotOptions)) + 1;
-        const process2Name = 'process-2';
-        const process2BumpedV = (yield getVersionHelper(process2Name, context.polkadotOptions)) + 1;
-        const newProcesses = yield loadProcesses({
-            options: context.polkadotOptions,
-            data: multiple(process1Name, process1BumpedV, process2Name, process2BumpedV),
-        });
-        if (newProcesses.type !== 'ok') {
-            expect.fail('Expected new process creation to succeed');
-        }
-        expect(newProcesses.result[process1Name].message).to.deep.equal('Transaction for new process process-1 has been successfully submitted');
-        const process1Result = newProcesses.result[process1Name];
-        if (process1Result.type !== 'ok') {
-            expect.fail('Expected process1 creation to succeed');
-        }
-        expect(process1Result.result).to.deep.contain({
-            version: process1BumpedV,
-            status: 'Enabled',
-        });
-        const process2Result = newProcesses.result[process2Name];
-        if (process2Result.type !== 'ok') {
-            expect.fail('Expected process2 creation to succeed');
-        }
-        expect(process2Result.message).to.deep.equal('Transaction for new process process-2 has been successfully submitted');
-        expect(process2Result.result).to.deep.contain({
-            version: process2BumpedV,
-            status: 'Enabled',
-        });
-    }));
-});

package/build/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../src/index.ts","../src/version.ts","../src/lib/process/api.ts","../src/lib/process/constants.ts","../src/lib/process/hex.ts","../src/lib/process/index.ts","../src/lib/process/_tests_/unit.test.ts","../src/lib/types/error.ts","../src/lib/types/polkadot.d.ts","../src/lib/types/process.d.ts","../src/lib/types/validation.ts","../src/lib/utils/polkadot.ts","../tests/fixtures/processes.ts","../tests/fixtures/programs.ts","../tests/helpers/containers.ts","../tests/helpers/substrateHelper.ts","../tests/integration/command-functions.test.ts","../tests/integration/without-manual-seal.test.ts"],"version":"5.6.3"}