@serverless-devs/s 0.0.44 → 0.1.4-18cdd23b

package/scripts/tests/download-manager-test.ts

@@ -1,135 +0,0 @@
-import { DownloadManager } from "../../src/init/download-manager";
-import * as fs from "fs-extra";
-import * as download from "download";
-import * as path from "path";
-import * as os from "os";
-import * as childProcess from 'child_process';
-import * as urlParser from "../../src/utils/url-parser";
-import { expect } from "chai";
-const sinon = require('sinon');
-const assert = require('assert');
-
-
-describe('InitManager', function () {
-    let downloadManager: DownloadManager;
-
-    before(() => {
-        downloadManager = new DownloadManager();
-    });
-
-
-    describe('#downloadTemplateByUrl()', function () {
-        let sandbox = sinon.createSandbox();
-
-        beforeEach(() => {
-        });
-    
-        afterEach(() => {
-            sandbox.restore();
-        });
-
-        it('should download and copy for normal git template', async function () {
-            const notExistsDir = "notExistsDirJustForUnitTest";
-            const zipFile = "http://github.com/test/test.zip";
-            const repoName = "test";
-
-            sandbox.stub(downloadManager, 'proxyDownload');
-            const copySyncStub = sandbox.stub(fs, 'copySync');
-            await downloadManager.downloadTemplateByUrl({zipFile: zipFile, hasSubPath:false, repoName:repoName}, notExistsDir);
-            copySyncStub.calledWith(path.join(os.tmpdir(), repoName), notExistsDir, {dereference:true});
-        });
-
-        it('should download and copy sub dir for git template with subDir', async function () {
-            const notExistsDir = "notExistsDirJustForUnitTest";
-            const zipFile = "http://github.com/test/test.zip";
-            const repoName = "test";
-            const subpath = "subpath";
-
-            sandbox.stub(downloadManager, 'proxyDownload');
-            const copySyncStub = sandbox.stub(fs, 'copySync');
-            await downloadManager.downloadTemplateByUrl({zipFile: zipFile, hasSubPath:true, subPath:subpath, repoName:repoName}, notExistsDir);
-            const srcDir = path.join(os.tmpdir(), repoName, subpath);
-            const destDir = path.join(notExistsDir, subpath);
-            copySyncStub.calledWith(path.join(os.tmpdir(), repoName), notExistsDir, {dereference:true});
-        });
-
-        it('should throw error if output dir exists for http template', async function () {
-            const dir = "test";
-            const zipFile = "http://github.com/test/test.zip";
-            const repoName = "test";
-            const execStub = sandbox.stub(childProcess, 'exec');
-            sandbox.stub(fs, 'existsSync').returns(true);
-
-            try {
-                await downloadManager.downloadTemplateByUrl({zipFile: zipFile, hasSubPath:false, repoName:repoName}, dir);
-                assert.fail("should throw an error");
-            } catch(err) {
-                expect(err).to.match(/Directory already exists/);
-            }
-        });
-    });
-
-    describe('#downloadTemplateByGitClone()', function () {
-        let sandbox = sinon.createSandbox();
-
-        beforeEach(() => {
-        });
-    
-        afterEach(() => {
-            sandbox.restore();
-        });
-
-        it('should clone git template for git protocol', async function () {
-            const notExistsDir = "notExistsDirJustForUnitTest";
-            const url = "git@github.com:mochajs/mocha.git";
-            const execStub = sandbox.stub(childProcess, 'exec');
-
-            downloadManager.downloadTemplateByGitClone(urlParser.parse(url), notExistsDir);
-            execStub.calledWith(`git clone ${url} ${notExistsDir}`);
-        });
-
-        it('should throw error if output dir exists for git clone', async function () {
-            const dir = "test";
-            const url = "git@github.com:mochajs/mocha.git";
-            const execStub = sandbox.stub(childProcess, 'exec');
-            sandbox.stub(fs, 'existsSync').returns(true);
-
-            try {
-                await downloadManager.downloadTemplateByGitClone(urlParser.parse(url), dir);
-                assert.fail("should throw an error");
-            } catch(err) {
-                expect(err).to.match(/Directory already exists/);
-            }
-        });
-
-        it('should throw error if exec failed', async function () {
-            const notExistsDir = "notExistsDirJustForUnitTest";
-            const url = "git@github.com:mochajs/mocha.git";
-            const execStub = sandbox.stub(childProcess, 'exec');
-            execStub.throws(new Error("Failed"));
-
-            try {
-                await downloadManager.downloadTemplateByGitClone(urlParser.parse(url), notExistsDir);
-                assert.fail("should throw an error");
-            } catch(err) {
-                expect(err).to.match(/Failed/);
-            }
-        });
-    });
-
-    /*
-     async downloadTemplateByGitClone(url: URL.Url, outputDir: string) {
-        if (fs.existsSync(outputDir)) {
-            throw new Error("Directory already exists: " + outputDir);
-        }
-
-        let cmd = `git clone ${url.href} ${outputDir}`;
-        const exec = util.promisify(ChildProcess.exec);
-        try {
-            await exec(cmd);
-        } catch(err) {
-            throw err;
-        }
-    }
-*/
-});

package/scripts/tests/init-manager-test.ts

@@ -1,232 +0,0 @@
-import { InitManager } from "../../src/init/init-manager";
-import { DownloadManager } from "../../src/init/download-manager";
-import axios from "axios";
-import * as inquirer from "inquirer";
-
-const chai = require('chai');
-const sinon = require('sinon');
-chai.use(require('sinon-chai'));
-const { expect } = require('chai');
-const assert = require('assert');
-
-describe('InitManager', function () {
-    let initManager: InitManager;
-    
-    before(() => {
-        initManager = new InitManager();
-    });
-
-    describe('#init()', function () {
-        let sandbox = sinon.createSandbox();
-
-        beforeEach(() => {
-        });
-    
-        afterEach(() => {
-            sandbox.restore();
-        });
-
-        it('should init success if download url template succeeds', async function () {
-            try {
-                //stub to return
-                const downloadUrlTemplateStub = sandbox.stub(initManager, 'downloadUrlTemplate');
-                downloadUrlTemplateStub.resolves("success");
-                //call method
-                await initManager.init("https://github.com/TypeStrong/ts-node", "test provider");
-                //expect call once
-                expect(downloadUrlTemplateStub).to.have.been.calledOnce;
-            } catch (err) {
-                assert.fail(err);
-            }
-        });
-
-        it('should init success if download app template succeeds', async function () {
-            try {
-                const downloadAppTemplateStub = sandbox.stub(initManager, 'downloadAppTemplate');
-                //stub to return
-                downloadAppTemplateStub.resolves("success");
-                //call method
-                await initManager.init("test app", "test provider");
-                //expect call once
-                expect(downloadAppTemplateStub).to.have.been.calledOnce;
-            } catch (err) {
-                assert.fail(err);
-            }
-        });
-
-        it('should throw error if downloadAppTemplate fail', async function () {
-            try {
-                const downloadAppTemplateStub = sandbox.stub(initManager, 'downloadAppTemplate');
-                //(sinon) stub to throw a exception
-                downloadAppTemplateStub.rejects(new Error("Failed"));
-                //call method
-                await initManager.init("test app", "test provider");
-                //should not reach
-                assert.fail("Exception not thrown");
-            } catch (err) {
-                //use Chai to check error thrown if expected
-                expect(err).to.match(/Failed/);
-            }
-        });
-
-        it('should throw error if downloadUrlTemplate fail', async function () {
-            try {
-                //stub to throw a exception
-                const downloadUrlTemplateStub = sandbox.stub(initManager, 'downloadUrlTemplate');
-                downloadUrlTemplateStub.rejects(new Error("Failed"));
-                //call method
-                await initManager.init("https://github.com/TypeStrong/ts-node", "test provider");
-                //should not reach
-                assert.fail("Exception not thrown");
-            } catch (err) {
-                //use Chai to check error thrown if expected
-                expect(err).to.match(/Failed/);
-            }
-        });
-
-    });
-
-    describe('#downloadAppTemplate()', function () {
-        let sandbox = sinon.createSandbox();
-
-        beforeEach(() => {
-        });
-    
-        afterEach(() => {
-            sandbox.restore();
-        });
-
-        it('should call getAppProvider if provider not provided', async function () {
-            const provider = "Aliyun";
-            const project = "test project";
-            
-            const getAppProviderStub = sandbox.stub(initManager, "getAppProvider");
-            getAppProviderStub.resolves(provider);
-            //stub app download
-            const getAppDownloadUrlStub = sandbox.stub(initManager, "getAppDownloadUrl");
-            getAppDownloadUrlStub.withArgs(project, provider).resolves("https://oss.aliyun.com/app");
-            //stub downloadManager
-            let downloadManager = new DownloadManager();
-            sandbox.stub(initManager, "downloadManager").value(downloadManager);
-            //stub downloadManager.downloadTemplateByUrl
-            const downloadTemplateByUrlStub = sandbox.stub(downloadManager, "downloadTemplateByUrl");
-            downloadTemplateByUrlStub.resolves("success")
-            //call method
-            await initManager.downloadAppTemplate(project);
-            expect(getAppProviderStub).to.have.been.calledOnce;
-        });
-
-        it('should throw InitError if get provider failed', async function() {
-            const provider = "Aliyun";
-            const project = "test project";
-
-            const getAppProviderStub = sandbox.stub(initManager, "getAppProvider");
-            const msg = "Failed to get app provider";
-            getAppProviderStub.rejects(new Error(msg));
-            //call method
-            try {
-                await initManager.downloadAppTemplate(project);
-                assert.fail('should thrown a error');
-            } catch(err) {
-                expect(err.message).to.include(msg);
-            }
-        });
-    });
-
-    describe('#getAppDownloadUrl()', function () {
-        let sandbox = sinon.createSandbox();
-
-        beforeEach(() => {
-        });
-    
-        afterEach(() => {
-            sandbox.restore();
-        });
-
-        it('should return app download url if request successfully', async function () {
-            const appDownloadUrl = "https://oss.aliyun.com";
-            sandbox.stub(axios, 'request').resolves({status: 200, data:{Response:{Url: appDownloadUrl}}});
-            //call
-            const url = await initManager.getAppDownloadUrl("test project", "test provider");
-            expect(url).to.equal(appDownloadUrl);
-        });
-    });
-
-    describe('#getAppProvider()', function () {
-        let sandbox = sinon.createSandbox();
-
-        beforeEach(() => {
-        });
-    
-        afterEach(() => {
-            sandbox.restore();
-        });
-
-        it('should return app providers if request successfully', async function () {
-            const aliyunProvider = "Aliyun";
-            sandbox.stub(axios, 'request').resolves({status: 200, data:{Response:{Providers: [aliyunProvider]}}});
-            sandbox.stub(inquirer, 'prompt').resolves({provider: aliyunProvider});
-            //call
-            const provider = await initManager.getAppProvider("test project");
-            expect(provider).to.equal(aliyunProvider);
-        
-        });
-    });
-
-    describe('#downloadUrlTemplate()', function () {
-        let sandbox = sinon.createSandbox();
-
-        beforeEach(() => {
-        });
-    
-        afterEach(() => {
-            sandbox.restore();
-        });
-
-        it('should call downloadManager.downloadTemplateByUrl() for http git address', async function () {
-            const url = "https://github.com/mochajs/mocha";
-
-            let downloadManager = new DownloadManager();
-            sandbox.stub(initManager, "downloadManager").value(downloadManager);
-            const downloadTemplateByUrlStub = sandbox.stub(downloadManager, "downloadTemplateByUrl");
-            
-            await initManager.downloadUrlTemplate(url);
-
-            expect(downloadTemplateByUrlStub).to.have.been.calledOnce;
-        });
-
-        it('should call downloadManager.downloadTemplateByUrl() for http git address', async function () {
-            const url = "git@github.com:mochajs/mocha.git";
-
-            let downloadManager = new DownloadManager();
-            sandbox.stub(initManager, "downloadManager").value(downloadManager);
-            const downloadTemplateByGitCloneStub = sandbox.stub(downloadManager, "downloadTemplateByGitClone");
-            
-            await initManager.downloadUrlTemplate(url);
-
-            expect(downloadTemplateByGitCloneStub).to.have.been.calledOnce;
-        });
-
-        it('should throw error if unexpected protocol', async function () {
-            const url = "ssh://host";
-
-            try {
-                await initManager.downloadUrlTemplate(url);
-                assert.fail("should throw an error");
-            } catch(err) {
-                expect(err).to.match(/Unknown project format/);
-            }
-        });
-
-        it('should throw error if unexpected host', async function () {
-            const url = "http://unknown.com/";
-
-            try {
-                await initManager.downloadUrlTemplate(url);
-                assert.fail("should throw an error");
-            } catch(err) {
-                expect(err).to.match(/Unknown host/);
-            }
-        });
-    });
-});

package/scripts/tests/url-parser-test.ts

@@ -1,44 +0,0 @@
-import * as urlParser from "../../src/utils/url-parser";
-const sinon = require('sinon');
-const assert = require('assert');
-
-
-describe('UrlParser', function () {
-
-    describe('#getProjectNameFromUrl()', function () {
-        let sandbox = sinon.createSandbox();
-
-        beforeEach(() => {
-        });
-    
-        afterEach(() => {
-            sandbox.restore();
-        });
-
-        it('should extract project name for http git url without .git', async function () {
-            const url = "https://github.com/mochajs/mocha";
-            const name = urlParser.getProjectNameFromUrl(url);
-            assert.equal(name, "mocha");
-        });
-
-        it('should extract template for http git url with .git', async function () {
-            const url = "https://github.com/mochajs/mocha.git";
-            const {repoName, branch, ownerName} = urlParser.extractTemplateInfo(urlParser.parse(url));
-            assert.equal(repoName, "mocha");
-            assert.equal(branch, "master");
-            assert.equal(ownerName, "mochajs");
-        });
-
-        it('should extract template for http git url without .git', async function () {
-            const url = "https://github.com/mochajs/mocha/tree/master/scripts";
-            const {repoName, branch, ownerName, subPath} = urlParser.extractTemplateInfo(urlParser.parse(url));
-            assert.equal(repoName, "mocha");
-            assert.equal(branch, "master");
-            assert.equal(ownerName, "mochajs");
-            assert.equal(subPath, "scripts");
-        });
-
-
-        //https://github.com/mochajs/mocha.git
-    });
-});

package/src/command/command-manager.ts

@@ -1,83 +0,0 @@
-
-const yaml = require('js-yaml');
-import { Parse } from '../utils/parse';
-import { Analysis } from '../utils/analysis';
-import { checkTemplateFile } from '../utils/common';
-import i18n from '../utils/i18n';
-import { TEMPLATE_FILE } from '../constants/static-variable';
-// eslint-disable-next-line no-unused-vars
-import { ComponentExeCute, ComponentConfig, generateSynchronizeComponentExeList, synchronizeExecuteComponentList } from '../component';
-import * as logger from '../utils/logger';
-
-
-export default class CommandManager {
-  protected deployParams: any
-  constructor(protected templateFile: string, protected method: string, protected customerCommandName?: string, params?: any) {
-    this.deployParams = params;
-  }
-
-  async assemblyProjectConfig(parse: Parse, projectName: string, parsedObj: any): Promise<ComponentConfig> {
-    const realVariables = await parse.getRealVariables(parsedObj); // Get the original conversion data
-    const projectConfig = realVariables[projectName];
-    projectConfig.ProjectName = projectName;
-    if (this.deployParams) {
-      projectConfig.Params = this.deployParams;
-    }
-    return projectConfig;
-  }
-
-
-  async init(): Promise<void> {
-    try {
-      logger.info(i18n.__('Start ......'));
-      const templateFile = checkTemplateFile(this.templateFile);
-      if (templateFile) {
-        let outPutData: any = {};
-        const parse = new Parse(templateFile);
-        const parsedObj = parse.getOriginalParsedObj();
-
-        if (this.customerCommandName) {
-          const projectConfig = await this.assemblyProjectConfig(parse, this.customerCommandName, parsedObj);
-          const componentExecute = new ComponentExeCute(projectConfig, this.method);
-          const tempResult = await componentExecute.init();
-          if (tempResult) {
-            outPutData[projectConfig.ProjectName] = tempResult;
-          }
-        } else {
-          const params = this.deployParams || '';
-          const realVariables = await parse.getRealVariables(parsedObj); // Get the original conversion data
-          const analysis = new Analysis(realVariables, parse.dependenciesMap);
-          const executeOrderList = analysis.getProjectOrder();
-          logger.info(i18n.__('It is detected that your project has the following project/projects < {{projects}} > to be execute', { projects: executeOrderList.join(',') }));
-          const componentList = generateSynchronizeComponentExeList({ list: executeOrderList, parse, parsedObj, method: this.method, params}, this.assemblyProjectConfig.bind(this));
-          const tempResult = await synchronizeExecuteComponentList(componentList);
-          for (const item in tempResult) {
-            if (executeOrderList.includes(item) && tempResult[item]) {
-              outPutData[item] = tempResult[item];
-            }
-          }
-        }
-
-        let outResult: any;
-        try {
-          outResult = yaml.safeDump(JSON.parse(JSON.stringify(outPutData)));
-        } catch (ex) {
-          logger.error(ex);
-          logger.warning('Unable to format the output, the system will display the original output of the component:');
-          outResult = JSON.stringify(outPutData, null, '  ');
-        }
-
-        logger.success(Object.keys(outPutData).length === 0 ? i18n.__('End of method: {{method}}', { method: this.method }) : outResult);
-      } else {
-        logger.error(i18n.__('Cannot find {{template}} file, please check the directory {{filepath}}', { template: TEMPLATE_FILE, filepath: this.templateFile }));
-      }
-    } catch (e) {
-      logger.error(e.message);
-    }
-
-  }
-
-
-}
-
-

package/src/command/index.ts

@@ -1,42 +0,0 @@
-const { Command } = require('commander');
-import CommandManager from './command-manager';
-import { PROCESS_ENV_TEMPLATE_NAME } from '../constants/static-variable';
-
-
-export default function create(command: string, customerCommandName?: string, description?: string) {
-  let params: Array<string> = [];
-  const _command = new Command(command);
-  let processArgv: Array<string> = [];
-  let start = false;
-
-  for (let i = 0; i < process.argv.length; i++) {
-    if (!start) {
-      processArgv.push(process.argv[i]);
-    } else {
-      params.push(process.argv[i]);
-    }
-    if (process.argv[i] === command) {
-      start = true;
-    }
-  }
-
-  if (params.length !== 0) {
-    process.env.temp_params = params.join(' ');
-  } else {
-    params = process.env.temp_params ? process.env.temp_params.split(' ') : [];
-  }
-
-  process.argv = processArgv;
-
-  _command
-    .description(description || '')
-    .action(() => {
-      const template: string | undefined = process['env'][PROCESS_ENV_TEMPLATE_NAME];
-      if (template) {
-        const commandManager = new CommandManager(template, command, customerCommandName, params.join(' '));
-        commandManager.init();
-      }
-    });
-  return _command;
-}
-

package/src/component/hook.ts

@@ -1,88 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-const util = require('util');
-import i18n from '../utils/i18n';
-const exec = util.promisify(require('child_process').exec);
-import { PluginExeCute } from '../plugin';
-import * as logger from '../utils/logger';
-export interface HookConfig {
-  Pre: boolean;
-  Plugin?: string;
-  Hook?: string;
-  Path?: string;
-}
-export class Hook {
-  preHooks: Array<HookConfig> = [];
-  afterHooks: Array<HookConfig> = [];
-  constructor(extendsParams: Array<HookConfig> = []) {
-    extendsParams.forEach((_extend: HookConfig) => {
-      if (_extend.Pre) {
-        this.preHooks.push(_extend);
-      } else {
-        this.afterHooks.push(_extend);
-      }
-    });
-  }
-
-  async executePreHook() {
-    if (this.preHooks.length > 0) {
-      logger.info(i18n.__('Start the pre-hook'));
-      for (let i = 0;i < this.preHooks.length;i++) {
-        logger.info(`[Hook / Plugin] ${this.preHooks[i]['Hook'] || this.preHooks[i]['Plugin']}`);
-        try {
-          await this.executeByConfig(this.preHooks[i]);
-        } catch (ex) {
-          logger.error(`[Hook / Plugin] [Error]: ${ex.stdout || ex.stderr}`);
-        }
-      }
-      logger.info(i18n.__('End the pre-hook'));
-    }
-  }
-
-  async executeAfterHook() {
-    if (this.afterHooks.length > 0) {
-      logger.info(i18n.__('Start the after-hook'));
-
-      // 2020-9-23 修复afterHooks无法处理的bug
-      for (let i = 0;i < this.afterHooks.length;i++) {
-        logger.info(`[Hook / Plugin] ${this.afterHooks[i]['Hook'] || this.afterHooks[i]['Plugin']}`);
-        try {
-          await this.executeByConfig(this.afterHooks[i]);
-        } catch (ex) {
-          logger.error(`[Hook / Plugin] [Error]: ${ex.stdout || ex.stderr}`);
-        }
-      }
-      logger.info(i18n.__('End the after-hook'));
-    }
-
-  }
-  async commandExecute(command: string, executePath: string | undefined) {
-    const currentDir = process.cwd();
-    const cwdPath = executePath ? path.resolve(currentDir, executePath) : currentDir;
-    if (fs.existsSync(cwdPath) && fs.lstatSync(cwdPath).isDirectory()) {
-      process.env['next-command-execute-flag'] = 'true';
-      logger.info(i18n.__('Executing ...'));
-      const { stdout, stderr } = await exec(command, { cwd: cwdPath });
-      if (stderr) {
-        logger.error(i18n.__('Execute:'), stderr);
-      } else {
-        logger.info(i18n.__('Execute:'), stdout);
-      }
-    }
-  }
-
-  async pluginExecute(name: string) {
-    const pluginInstance = new PluginExeCute({ name });
-    await pluginInstance.init();
-    const pluginModule = await pluginInstance.loadPlugin();
-    pluginModule.apply(null, []);
-  }
-
-  async executeByConfig(hookConfig: HookConfig) {
-    if (hookConfig.Hook) {
-      await this.commandExecute(hookConfig.Hook, hookConfig.Path);
-    } else if (hookConfig.Plugin) {
-      await this.pluginExecute(hookConfig.Plugin);
-    }
-  }
-}