Merge pull request #3 from serverless-tencent/testing

add test case

Author: tinafangkunding

deploy/lib/deployFunction.test.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const sinon          = require('sinon');
+const DeployFunction = require('./deployFunction');
+
+describe('DeployFunction@Library', () => {
+    let deployFunction;
+    let deployFunctionStub;
+    let updateFunctionCodeStub;
+    let createFunctionStub;
+    let getFunctionStub;
+    let updateConfigurationStub;
+    let createTagsStub;
+    let uploadService2CosStub;
+
+    let options;
+
+    beforeEach(() => {
+        options = {
+            region: 'ap-guangzhou',
+        };
+        deployFunction = new DeployFunction('appid', 'secret_id', 'secret_key', options);
+
+        deployFunctionStub = sinon.stub(deployFunction, 'deploy')
+            .returns(Promise.resolve());
+        updateFunctionCodeStub = sinon.stub(deployFunction, 'updateFunctionCode')
+            .returns(Promise.resolve());
+        createFunctionStub = sinon.stub(deployFunction, 'createFunction')
+            .returns(Promise.resolve());
+        getFunctionStub = sinon.stub(deployFunction, 'getFunction')
+            .returns(Promise.resolve());
+        updateConfigurationStub = sinon.stub(deployFunction, 'updateConfiguration')
+        	.returns(Promise.resolve());
+        createTagsStub = sinon.stub(deployFunction, 'createTags')
+        	.returns(Promise.resolve());
+        uploadService2CosStub = sinon.stub(deployFunction, 'uploadService2Cos')
+        	.returns(Promise.resolve());
+
+    });
+
+    afterEach(() => {
+        deployFunction.deploy.restore();
+        deployFunction.updateFunctionCode.restore();
+        deployFunction.createFunction.restore();
+        deployFunction.getFunction.restore();
+        deployFunction.updateConfiguration.restore();
+        deployFunction.createTags.restore();
+        deployFunction.uploadService2Cos.restore();
+    });
+
+    it('should make the deploy function accessible', () => {
+        deployFunction.should.to.be.an.instanceof(DeployFunction);
+    });
+
+    it('should run library deploy function', () => deployFunction
+        .deploy().then(()=>{
+        deployFunctionStub.calledOnce.should.equal(true)
+    }));
+
+    it('should run library update function code', () => deployFunction
+        .updateFunctionCode().then(()=>{
+        updateFunctionCodeStub.calledOnce.should.equal(true)
+    }));
+
+    it('should run library create function', () => deployFunction
+        .createFunction().then(()=>{
+        createFunctionStub.calledOnce.should.equal(true)
+    }));
+
+    it('should run library get function', () => deployFunction
+        .getFunction().then(()=>{
+        getFunctionStub.calledOnce.should.equal(true)
+    }));
+
+    it('should run library update configuration', () => deployFunction
+        .updateConfiguration().then(()=>{
+        updateConfigurationStub.calledOnce.should.equal(true)
+    }));
+
+    it('should run library create tags', () => deployFunction
+        .createTags().then(()=>{
+        createTagsStub.calledOnce.should.equal(true)
+    }));
+    it('should run library upload service to cos', () => deployFunction
+        .uploadService2Cos().then(()=>{
+        uploadService2CosStub.calledOnce.should.equal(true)
+    }));
+});

deploy/lib/deployListFunctions.test.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const sinon               = require('sinon');
+const DeployListFunctions = require('./deployListFunctions');
+
+describe('DeployListFunctions@Library', () => {
+    let deployListFunctions;
+    let deployListFunctionsStub;
+
+    let options;
+
+    beforeEach(() => {
+        options = {
+            region: 'ap-guangzhou',
+        };
+        deployListFunctions = new DeployListFunctions('appid', 'secret_id', 'secret_key', options);
+
+        deployListFunctionsStub = sinon.stub(deployListFunctions, 'functionsList')
+            .returns(Promise.resolve());
+    });
+
+    afterEach(() => {
+        deployListFunctions.functionsList.restore();
+    });
+
+    it('should make the info function accessible', () => {
+        deployListFunctions.should.to.be.an.instanceof(DeployListFunctions);
+    });
+
+    it('should run library functions list', () => deployListFunctions
+        .functionsList().then(()=>{
+        deployListFunctionsStub.calledOnce.should.equal(true)
+    }));
+});

deploy/lib/deployTrigger.test.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const sinon         = require('sinon');
+const DeployTrigger = require('./deployTrigger');
+
+describe('DeployTrigger@Library', () => {
+    let deployTrigger;
+    let deployTriggerCreateStub;
+
+    let options;
+
+    beforeEach(() => {
+        options = {
+            region: 'ap-guangzhou',
+        };
+        deployTrigger = new DeployTrigger('appid', 'secret_id', 'secret_key', options);
+
+        deployTriggerCreateStub = sinon.stub(deployTrigger, 'create')
+            .returns(Promise.resolve());
+    });
+
+    afterEach(() => {
+        deployTrigger.create.restore();
+    });
+
+    it('should make the info function accessible', () => {
+        deployTrigger.should.to.be.an.instanceof(DeployTrigger);
+    });
+
+    it('should run library create trigger', () => deployTrigger
+        .create().then(()=>{
+        deployTriggerCreateStub.calledOnce.should.equal(true)
+    }));
+});

deploy/tencentDeploy.js

@@ -27,7 +27,8 @@ class TencentDeploy {
 				.then(this.validate)
 				.then(this.setDefaults),
 
-			'deploy:deploy': this.deploy.bind(this),
+			'deploy:deploy': () => BbPromise.bind(this)
+				.then(this.deploy),
 		};
 	}
 

deploy/tencentDeploy.test.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const fs              = require('fs');
+const os              = require('os');
+const sinon           = require('sinon');
+const TencentProvider = require('../provider/tencentProvider');
+const Serverless      = require('../test/serverless');
+const TencentDeploy   = require('./tencentDeploy');
+
+describe('TencentDeploy', () => {
+    let serverless;
+    let options;
+    let tencentDeploy;
+    let readFileSyncStub;
+    let homedirStub;
+
+    beforeEach(() => {
+        serverless = new Serverless();
+        options = {
+            stage: 'dev',
+            region: 'ap-guangzhou',
+            function: 'test'
+        };
+
+        readFileSyncStub = sinon.stub(fs, 'readFileSync')
+            .returns(`[default]
+tencent_secret_key = PYR4a0HSZ******eVvHRe
+tencent_secret_id = AKIDoM*****mxsfOirI
+tencent_appid = 12561*****`);
+        homedirStub = sinon.stub(os, 'homedir')
+            .returns('/root');
+
+        serverless.setProvider('tencent', new TencentProvider(serverless, options));
+        tencentDeploy = new TencentDeploy(serverless, options);
+    });
+
+    afterEach(() => {
+        fs.readFileSync.restore();
+        os.homedir.restore();
+    });
+
+    describe('#constructor()', () => {
+        it('should set the serverless instance', () => {
+            tencentDeploy.serverless.should.equal(serverless);
+        });
+
+        it('should set options if provided', () => {
+            tencentDeploy.options.should.equal(options);
+        });
+
+        it('should make the provider accessible', () => {
+            tencentDeploy.provider.should.to.be.an.instanceof(TencentProvider);
+        });
+
+        describe('hooks', () => {
+            let validateStub;
+            let setDefaultsStub;
+            let tencentDeployStub;
+
+            beforeEach(() => {
+                validateStub = sinon.stub(tencentDeploy, 'validate')
+                    .returns(Promise.resolve());
+                setDefaultsStub = sinon.stub(tencentDeploy, 'setDefaults')
+                    .returns(Promise.resolve());
+                tencentDeployStub = sinon.stub(tencentDeploy, 'deploy')
+                    .returns(Promise.resolve());
+            });
+
+            afterEach(() => {
+                tencentDeploy.validate.restore();
+                tencentDeploy.setDefaults.restore();
+                tencentDeploy.deploy.restore();
+            });
+
+            it('should run "before:deploy:deploy" promise chain', () => tencentDeploy
+                .hooks['before:deploy:deploy']().then(() => {
+                    validateStub.calledOnce.should.equal(true);
+                    setDefaultsStub.calledAfter(validateStub).should.equal(true);
+                }));
+
+            it('should run "deploy:deploy" promise chain', () => tencentDeploy
+                .hooks['deploy:deploy']().then(() => {
+                    tencentDeployStub.calledOnce.should.equal(true);
+                }));
+        });
+    });
+});

deploy/tencentDeployFunction.js

@@ -26,8 +26,10 @@ class TencentDeployFunction {
 			'deploy:function:initialize': () => BbPromise.bind(this)
 				.then(this.validate)
 				.then(this.setDefaults),
-			'deploy:function:packageFunction': this.packageFunction.bind(this),
-			'deploy:function:deploy': this.deploy.bind(this),
+			'deploy:function:packageFunction': () => BbPromise.bind(this)
+				.then(this.packageFunction),
+			'deploy:function:deploy': () => BbPromise.bind(this)
+				.then(this.deploy),
 		};
 	}
 

deploy/tencentDeployFunction.test.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const fs                    = require('fs');
+const os                    = require('os');
+const sinon                 = require('sinon');
+const TencentProvider       = require('../provider/tencentProvider');
+const Serverless            = require('../test/serverless');
+const TencentDeployFunction = require('./tencentDeployFunction');
+
+describe('TencentDeployFunction', () => {
+    let serverless;
+    let options;
+    let tencentDeployFunction;
+    let readFileSyncStub;
+    let homedirStub;
+
+    beforeEach(() => {
+        serverless = new Serverless();
+        options = {
+            stage: 'dev',
+            region: 'ap-guangzhou',
+            function: 'test'
+        };
+
+        readFileSyncStub = sinon.stub(fs, 'readFileSync')
+            .returns(`[default]
+tencent_secret_key = PYR4a0HSZ******eVvHRe
+tencent_secret_id = AKIDoM*****mxsfOirI
+tencent_appid = 12561*****`);
+        homedirStub = sinon.stub(os, 'homedir')
+            .returns('/root');
+
+        serverless.setProvider('tencent', new TencentProvider(serverless, options));
+        tencentDeployFunction = new TencentDeployFunction(serverless, options);
+    });
+
+    afterEach(() => {
+        fs.readFileSync.restore();
+        os.homedir.restore();
+    });
+
+    describe('#constructor()', () => {
+        it('should set the serverless instance', () => {
+            tencentDeployFunction.serverless.should.equal(serverless);
+        });
+
+        it('should set options if provided', () => {
+            tencentDeployFunction.options.should.equal(options);
+        });
+
+        it('should make the provider accessible', () => {
+            tencentDeployFunction.provider.should.to.be.an.instanceof(TencentProvider);
+        });
+
+        describe('hooks', () => {
+            let validateStub;
+            let setDefaultsStub;
+            let tencentDeployFunctionStub;
+            let tencentPackageFunctionStub;
+
+            beforeEach(() => {
+                validateStub = sinon.stub(tencentDeployFunction, 'validate')
+                    .returns(Promise.resolve());
+                setDefaultsStub = sinon.stub(tencentDeployFunction, 'setDefaults')
+                    .returns(Promise.resolve());
+                tencentDeployFunctionStub = sinon.stub(tencentDeployFunction, 'deploy')
+                    .returns(Promise.resolve());
+                tencentPackageFunctionStub = sinon.stub(tencentDeployFunction, 'packageFunction')
+                    .returns(Promise.resolve());
+            });
+
+            afterEach(() => {
+                tencentDeployFunction.validate.restore();
+                tencentDeployFunction.setDefaults.restore();
+                tencentDeployFunction.deploy.restore();
+            });
+
+            it('should run "deploy:function:initialize" promise chain', () => tencentDeployFunction
+                .hooks['deploy:function:initialize']().then(() => {
+                    validateStub.calledOnce.should.equal(true);
+                    setDefaultsStub.calledAfter(validateStub).should.equal(true);
+                }));
+
+           	it('should run "deploy:function:packageFunction" promise chain', () => tencentDeployFunction
+                .hooks['deploy:function:packageFunction']().then(() => {
+                    tencentPackageFunctionStub.calledOnce.should.equal(true);
+                }));
+
+            it('should run "deploy:function:deploy" promise chain', () => tencentDeployFunction
+                .hooks['deploy:function:deploy']().then(() => {
+                    tencentDeployFunctionStub.calledOnce.should.equal(true);
+                }));
+        });
+    });
+});

deploy/tencentDeployList.js

@@ -23,7 +23,8 @@ class TencentDeployList {
             'before:deploy:list:log': () => BbPromise.bind(this)
                 .then(this.validate)
                 .then(this.setDefaults),
-            'deploy:list:log': this.serviceList.bind(this),
+            'deploy:list:log': () => BbPromise.bind(this)
+                .then(this.serviceList),
         };
     }