@sprucelabs/spruce-cli/build/__tests__/behavioral/upgrading/UpdatingDependencies2.test.js

Command line interface for building Spruce skills.

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const test_utils_1 = require("@sprucelabs/test-utils");
const lodash_1 = require("lodash");
const CommandService_1 = __importDefault(require("../../../services/CommandService"));
const AbstractCliTest_1 = __importDefault(require("../../../tests/AbstractCliTest"));
class UpdateDependencies2Test extends AbstractCliTest_1.default {
    static action;
    static async beforeEach() {
        await super.beforeEach();
        this.action = this.Action('node', 'updateDependencies');
    }
    static async locksVersionOfDependencyWhenDependencyAlreadyInPackageJson() {
        await this.FeatureFixture().installCachedFeatures('skills');
        this.Service('pkg').set({ path: 'dependencies.axios', value: '0.0.1' });
        const skill = this.featureInstaller.getFeature('skill');
        skill.packageDependencies.push({
            name: 'axios',
            version: '0.21.3',
        });
        const passedArgs = [];
        CommandService_1.default.fakeCommand(/(npm|yarn).*?(install|add)/, {
            code: 0,
            callback: (_, args) => {
                passedArgs.push(...args);
            },
        });
        await this.action.execute({});
        test_utils_1.assert.doesInclude(passedArgs, 'axios@0.21.3');
    }
    static async runsAddForAllDependenciesInPkgJson() {
        await this.FeatureFixture().installCachedFeatures('events');
        const name = await this.installRandomPackage();
        const devName = await this.installRandomDevPackage();
        const blocked = this.blockRandomPackages();
        const { allDeps, allDevDeps } = this.loadAllDependencies(name, devName);
        let passedArgs = [];
        CommandService_1.default.fakeCommand(/(npm|yarn).*?(install|add)/, {
            code: 0,
            callback: (_, args) => {
                passedArgs.push(args);
            },
        });
        await this.action.execute({});
        const pkg = this.Service('pkg');
        const features = await this.featureInstaller.getInstalledFeatures();
        for (const feature of features) {
            const featureDependencies = feature.packageDependencies;
            const deps = (0, lodash_1.uniq)([
                ...allDeps,
                ...featureDependencies
                    .filter((d) => !d.isDev && !allDevDeps.includes(d.name))
                    .map((d) => d.name),
            ]
                .map((n) => pkg.stripLatest(n))
                .filter((n) => n !== blocked));
            const devDeps = (0, lodash_1.uniq)([
                ...allDevDeps,
                ...featureDependencies
                    .filter((d) => d.isDev && !allDeps.includes(d.name))
                    .map((d) => d.name),
            ]
                .map((n) => pkg.stripLatest(n))
                .filter((n) => n !== blocked));
            for (const d of deps) {
                test_utils_1.assert.doesInclude(passedArgs[0], d);
            }
            for (const d of devDeps) {
                test_utils_1.assert.doesInclude(passedArgs[1], d);
            }
        }
        test_utils_1.assert.doesNotInclude(passedArgs[0], blocked);
        test_utils_1.assert.doesNotInclude(passedArgs[1], blocked);
    }
    static loadAllDependencies(name, devName) {
        const pkg = this.Service('pkg');
        const pkgJson = pkg.readPackage();
        const allDeps = [...(Object.keys(pkgJson.dependencies) ?? []), name];
        const allDevDeps = [
            ...(Object.keys(pkgJson.devDependencies) ?? []),
            devName,
        ];
        return { allDeps, allDevDeps };
    }
    static async installRandomPackage() {
        const names = ['moment', 'lodash'];
        const name = names[(0, lodash_1.random)(0, names.length - 1)];
        const pkg = this.Service('pkg');
        await pkg.install(name);
        return name;
    }
    static async installRandomDevPackage() {
        const names = ['chalk', 'axios'];
        const name = names[(0, lodash_1.random)(0, names.length - 1)];
        const pkg = this.Service('pkg');
        await pkg.install(name, { isDev: true });
        return name;
    }
    static blockRandomPackages() {
        const names = ['@sprucelabs/error', 'typescript'];
        const name = names[(0, lodash_1.random)(0, names.length - 1)];
        this.action.blockUpgrade(name, this.Service('pkg'));
        this.action.blockUpgrade('random', this.Service('pkg'));
        return name;
    }
}
exports.default = UpdateDependencies2Test;
__decorate([
    (0, test_utils_1.test)()
], UpdateDependencies2Test, "locksVersionOfDependencyWhenDependencyAlreadyInPackageJson", null);
__decorate([
    (0, test_utils_1.test)()
], UpdateDependencies2Test, "runsAddForAllDependenciesInPkgJson", null);
//# sourceMappingURL=UpdatingDependencies2.test.js.map