archive-gh-me/serverless
1
0
Fork 0
mirror of https://github.com/serverless/serverless.git synced 2026-01-25 15:07:39 +00:00
Code Issues Projects Releases Wiki Activity

test: Upgrade @serverless/test to v9

Browse Source
This commit is contained in:
Mariusz Nowak 2021-11-10 16:08:18 +01:00 committed by Mariusz Nowak
parent f4e499b4bf
commit b30a2277a7
26 changed files with 235 additions and 3880 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
package.json
View File

@ -81,7 +81,7 @@
"devDependencies": {
"@commitlint/cli": "^12.1.4",
"@serverless/eslint-config": "^4.0.0",
"@serverless/test": "^8.8.0",
"@serverless/test": "^9.0.0",
"adm-zip": "^0.5.9",
"chai": "^4.3.4",
"chai-as-promised": "^7.1.1",

18
test/unit/lib/classes/Error.test.js
View File

@ -1,18 +0,0 @@
'use strict';
const expect = require('chai').expect;
const overrideStdoutWrite = require('process-utils/override-stdout-write');
const { logWarning } = require('../../../../lib/classes/Error');
describe('#logWarning()', () => {
it('should log warning and proceed', () => {
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => logWarning('a message')
);
expect(stdoutData).to.have.string('Serverless Warning');
expect(stdoutData).to.have.string('a message');
});
});

2915
test/unit/lib/classes/Variables.test.js
View File

File diff suppressed because it is too large Load Diff

144
test/unit/lib/cli/handle-error.test.js
View File

@ -3,8 +3,7 @@
const chai = require('chai');
const sinon = require('sinon');
const path = require('path');
const overrideStdoutWrite = require('process-utils/override-stdout-write');
const observeOutput = require('@serverless/test/observe-output');
const handleError = require('../../../../lib/cli/handle-error');
const isStandaloneExecutable = require('../../../../lib/utils/isStandaloneExecutable');
const ServerlessError = require('../../../../lib/serverless-error');
@ -15,31 +14,19 @@ chai.use(require('sinon-chai'));
const expect = chai.expect;
describe('test/unit/lib/cli/handle-error.test.js', () => {
it('should log environment information', async () => {
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
() => handleError(new ServerlessError('Test error'))
);
expect(stdoutData).to.have.string('Serverless Error');
expect(stdoutData).to.have.string('Test error');
expect(stdoutData).to.have.string('Your Environment Information');
expect(stdoutData).to.have.string('Operating System:');
expect(stdoutData).to.have.string('Node Version:');
expect(stdoutData).to.have.string('Framework Version:');
expect(stdoutData).to.have.string('Plugin Version:');
expect(stdoutData).to.have.string('SDK Version:');
expect(stdoutData).to.have.string('Components Version:');
it('should output environment information', async () => {
const output = await observeOutput(() => handleError(new ServerlessError('Test error')));
expect(output).to.have.string('Environment: ');
expect(output).to.have.string('node');
expect(output).to.have.string('framework');
expect(output).to.have.string('plugin');
expect(output).to.have.string('SDK');
});
it('should support `isUncaughtException` option', async () => {
const processExitStub = sinon.stub(process, 'exit').returns();
try {
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
() => handleError(new ServerlessError('Test error'), { isUncaughtException: true })
);
await handleError(new ServerlessError('Test error'), { isUncaughtException: true });
expect(processExitStub.called).to.be.true;
} finally {
processExitStub.restore();
@ -48,57 +35,25 @@ describe('test/unit/lib/cli/handle-error.test.js', () => {
if (isStandaloneExecutable) {
it('should report standalone installation', async () => {
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
() => handleError(new ServerlessError('Test error'))
);
expect(stdoutData).to.have.string('(standalone)');
const output = await observeOutput(() => handleError(new ServerlessError('Test error')));
expect(output).to.have.string('(standalone)');
});
} else {
it('should support `isLocallyInstalled` option', async () => {
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
() => handleError(new ServerlessError('Test error'), { isLocallyInstalled: false })
const output = await observeOutput(() =>
handleError(new ServerlessError('Test error'), { isLocallyInstalled: false })
);
expect(stdoutData).to.not.have.string('(local)');
stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
() => handleError(new ServerlessError('Test error'), { isLocallyInstalled: true })
expect(output).to.not.have.string('(local)');
const output2 = await observeOutput(() =>
handleError(new ServerlessError('Test error'), { isLocallyInstalled: true })
);
expect(stdoutData).to.have.string('(local)');
expect(output2).to.have.string('(local)');
});
}
it('should print stack trace with SLS_DEBUG', async () => {
let stdoutData = '';
process.env.SLS_DEBUG = '1';
await overrideStdoutWrite(
(data) => (stdoutData += data),
() => handleError(new ServerlessError('Test error'))
);
expect(stdoutData).to.have.string(path.basename(__filename));
});
it('should not print stack trace without SLS_DEBUG', async () => {
let stdoutData = '';
delete process.env.SLS_DEBUG;
await overrideStdoutWrite(
(data) => (stdoutData += data),
() => handleError(new ServerlessError('Test error'))
);
expect(stdoutData).to.not.have.string(path.basename(__filename));
});
it('should handle non-error objects', async () => {
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
() => handleError('NON-ERROR')
);
expect(stdoutData).to.have.string('NON-ERROR');
const output = await observeOutput(() => handleError(handleError('NON-ERROR')));
expect(output).to.have.string('NON-ERROR');
});
describe('with mocked telemetry', () => {
@ -122,14 +77,9 @@ describe('test/unit/lib/cli/handle-error.test.js', () => {
});
it('should record telemetry only if `hasTelemetryBeenReported` is `false`', async () => {
// Override to avoid printing to stdout in tests
await overrideStdoutWrite(
() => {},
() =>
handleErrorWithMocks(new ServerlessError('Test error', 'ERR_CODE'), {
hasTelemetryBeenReported: false,
})
);
await handleErrorWithMocks(new ServerlessError('Test error', 'ERR_CODE'), {
hasTelemetryBeenReported: false,
});
expect(generateTelemetryPayloadStub).to.be.calledOnce;
expect(storeTelemetryLocallyStub).to.be.calledOnce;
expect(sendTelemetryStub).to.be.calledOnce;
@ -143,14 +93,9 @@ describe('test/unit/lib/cli/handle-error.test.js', () => {
});
it('should add `location` to `failureReason` in telemetry if error code missing', async () => {
// Override to avoid printing to stdout in tests
await overrideStdoutWrite(
() => {},
() =>
handleErrorWithMocks(new ServerlessError('Test error'), {
hasTelemetryBeenReported: false,
})
);
await handleErrorWithMocks(new ServerlessError('Test error'), {
hasTelemetryBeenReported: false,
});
expect(generateTelemetryPayloadStub).to.be.calledOnce;
expect(storeTelemetryLocallyStub).to.be.calledOnce;
expect(sendTelemetryStub).to.be.calledOnce;
@ -160,14 +105,9 @@ describe('test/unit/lib/cli/handle-error.test.js', () => {
});
it('should add `location` to `failureReason` in telemetry for non-user errors', async () => {
// Override to avoid printing to stdout in tests
await overrideStdoutWrite(
() => {},
() =>
handleErrorWithMocks(new Error('Test error'), {
hasTelemetryBeenReported: false,
})
);
await handleErrorWithMocks(new Error('Test error'), {
hasTelemetryBeenReported: false,
});
expect(generateTelemetryPayloadStub).to.be.calledOnce;
expect(storeTelemetryLocallyStub).to.be.calledOnce;
expect(sendTelemetryStub).to.be.calledOnce;
@ -177,25 +117,16 @@ describe('test/unit/lib/cli/handle-error.test.js', () => {
});
it('should not record telemetry if `hasTelemetryBeenReported` is `true`', async () => {
// Override to avoid printing to stdout in tests
await overrideStdoutWrite(
() => {},
() =>
handleErrorWithMocks(new ServerlessError('Test error'), {
hasTelemetryBeenReported: true,
})
);
await handleErrorWithMocks(new ServerlessError('Test error'), {
hasTelemetryBeenReported: true,
});
expect(generateTelemetryPayloadStub).not.to.be.called;
expect(storeTelemetryLocallyStub).not.to.be.called;
expect(sendTelemetryStub).not.to.be.called;
});
it('should not record telemetry if `hasTelemetryBeenReported` is not passed', async () => {
// Override to avoid printing to stdout in tests
await overrideStdoutWrite(
() => {},
() => handleErrorWithMocks(new ServerlessError('Test error'))
);
await handleErrorWithMocks(new ServerlessError('Test error'));
expect(generateTelemetryPayloadStub).not.to.be.called;
expect(storeTelemetryLocallyStub).not.to.be.called;
expect(sendTelemetryStub).not.to.be.called;
@ -205,14 +136,9 @@ describe('test/unit/lib/cli/handle-error.test.js', () => {
// Ensure that `commandSchema` is not included in result of `resolveInput`
resolveInputStub.returns({});
// Override to avoid printing to stdout in tests
await overrideStdoutWrite(
() => {},
() =>
handleErrorWithMocks(new ServerlessError('Test error'), {
hasTelemetryBeenReported: false,
})
);
await handleErrorWithMocks(new ServerlessError('Test error'), {
hasTelemetryBeenReported: false,
});
expect(generateTelemetryPayloadStub).not.to.be.called;
expect(storeTelemetryLocallyStub).not.to.be.called;
expect(sendTelemetryStub).not.to.be.called;

88
test/unit/lib/cli/interactive-setup/aws-credentials.test.js
View File

@ -197,7 +197,7 @@ describe('test/unit/lib/cli/interactive-setup/aws-credentials.test.js', () => {
).to.be.true;
});
it('Should emit warning when dashboard is not available when fetching providers', async () => {
it('Should be ineffective dashboard is not available', async () => {
const internalMockedSdk = {
...mockedSdk,
getProviders: async () => {
@ -213,20 +213,13 @@ describe('test/unit/lib/cli/interactive-setup/aws-credentials.test.js', () => {
'@serverless/dashboard-plugin/lib/isAuthenticated': () => true,
});
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () =>
expect(
await mockedStep.isApplicable({
serviceDir: process.cwd(),
configuration: { provider: { name: 'aws' }, org: 'someorg' },
configurationFilename: 'serverless.yml',
})
).to.be.false
);
expect(stdoutData).to.include('Serverless Dashboard is currently unavailable');
expect(
await mockedStep.isApplicable({
serviceDir: process.cwd(),
configuration: { provider: { name: 'aws' }, org: 'someorg' },
configurationFilename: 'serverless.yml',
})
).to.be.false;
});
it('Should be effective, at AWS service and no credentials are set', async () =>
@ -238,7 +231,7 @@ describe('test/unit/lib/cli/interactive-setup/aws-credentials.test.js', () => {
})
).to.equal(true));
it('Should emit a message when user decides to skip credentials setup', async () => {
it('Should allow to skip credentials setup', async () => {
configureInquirerStub(inquirer, {
list: { credentialsSetupChoice: '_skip_' },
});
@ -256,7 +249,6 @@ describe('test/unit/lib/cli/interactive-setup/aws-credentials.test.js', () => {
async () => await step.run(context)
);
expect(stdoutData).to.include('You can setup your AWS account later');
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([['credentialsSetupChoice', '_skip_']])
);
@ -464,7 +456,6 @@ describe('test/unit/lib/cli/interactive-setup/aws-credentials.test.js', () => {
list: { credentialsSetupChoice: '_create_provider_' },
});
let stdoutData = '';
const context = {
serviceDir: process.cwd(),
configuration: {
@ -477,12 +468,8 @@ describe('test/unit/lib/cli/interactive-setup/aws-credentials.test.js', () => {
configurationFilename: 'serverless.yml',
stepHistory: new StepHistory(),
};
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => await mockedStep.run(context)
);
await mockedStep.run(context);
expect(stdoutData).to.include('AWS Access Role provider was successfully created');
expect(mockedOpenBrowser).to.have.been.calledWith(
'https://app.serverless.com/someorg/settings/providers?source=cli&providerId=new&provider=aws'
);
@ -551,13 +538,8 @@ describe('test/unit/lib/cli/interactive-setup/aws-credentials.test.js', () => {
configurationFilename: 'serverless.yml',
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => await mockedStep.run(context)
);
await mockedStep.run(context);
expect(stdoutData).to.include('AWS Access Role provider was successfully created');
expect(mockedOpenBrowser).to.have.been.calledWith(
'https://app.serverless.com/someorg/settings/providers?source=cli&providerId=new&provider=aws'
);
@ -605,13 +587,8 @@ describe('test/unit/lib/cli/interactive-setup/aws-credentials.test.js', () => {
configurationFilename: 'serverless.yml',
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => await mockedStep.run(context)
);
await mockedStep.run(context);
expect(stdoutData).to.include('Serverless Dashboard is currently unavailable');
expect(mockedOpenBrowser).to.have.been.calledWith(
'https://app.serverless.com/someorg/settings/providers?source=cli&providerId=new&provider=aws'
);
@ -664,11 +641,7 @@ describe('test/unit/lib/cli/interactive-setup/aws-credentials.test.js', () => {
configurationFilename: 'serverless.yml',
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => await mockedStep.run(context)
);
await mockedStep.run(context);
expect(mockedCreateProviderLink).to.have.been.calledWith(
'org-uid',
@ -676,13 +649,12 @@ describe('test/unit/lib/cli/interactive-setup/aws-credentials.test.js', () => {
'appName|someapp|serviceName|someservice|stage|dev|region|us-east-1',
'provideruid'
);
expect(stdoutData).to.include('Selected provider was successfully linked');
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([['credentialsSetupChoice', '_user_choice_']])
);
});
it('Should emit a warning when dashboard is not available and link cannot be created', async () => {
it('Should handle gently dashboard unavailabiilty when linking provider', async () => {
const providerUid = 'provideruid';
const mockedCreateProviderLink = sinon.stub().callsFake(async () => {
const err = new Error('error');
@ -730,16 +702,7 @@ describe('test/unit/lib/cli/interactive-setup/aws-credentials.test.js', () => {
stepHistory: new StepHistory(),
configurationFilename: 'serverless.yml',
};
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => await mockedStep.run(context)
);
expect(stdoutData).to.include(
'Serverless Dashboard is currently unavailable, please try again later'
);
expect(stdoutData).not.to.include('Selected provider was successfully linked');
await mockedStep.run(context);
expect(mockedCreateProviderLink).to.have.been.calledWith(
'org-uid',
'instance',
@ -752,7 +715,7 @@ describe('test/unit/lib/cli/interactive-setup/aws-credentials.test.js', () => {
);
});
it('Should emit a warning when dashboard is not available when fetching providers', async () => {
it('Should handle gently dashboard unavailabiilty when fetching providers', async () => {
const internalMockedSdk = {
...mockedSdk,
getProviders: async () => {
@ -768,19 +731,12 @@ describe('test/unit/lib/cli/interactive-setup/aws-credentials.test.js', () => {
'@serverless/dashboard-plugin/lib/isAuthenticated': () => true,
});
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () =>
await mockedStep.run({
serviceDir: process.cwd(),
configuration: { provider: { name: 'aws' }, org: 'someorg' },
options: {},
configurationFilename: 'serverless.yml',
})
);
expect(stdoutData).to.include('Serverless Dashboard is currently unavailable');
await mockedStep.run({
serviceDir: process.cwd(),
configuration: { provider: { name: 'aws' }, org: 'someorg' },
options: {},
configurationFilename: 'serverless.yml',
});
});
});
});

23
test/unit/lib/cli/interactive-setup/dashboard-login.test.js
View File

@ -5,7 +5,6 @@ const sinon = require('sinon');
const proxyquire = require('proxyquire');
const overrideCwd = require('process-utils/override-cwd');
const configureInquirerStub = require('@serverless/test/configure-inquirer-stub');
const overrideStdoutWrite = require('process-utils/override-stdout-write');
const { StepHistory } = require('@serverless/utils/telemetry');
const inquirer = require('@serverless/utils/inquirer');
@ -123,20 +122,11 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-login.test.js', function
inquirer,
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
await loginStep.run(context);
}
);
await loginStep.run(context);
expect(loginStub.calledOnce).to.be.true;
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([['shouldLoginOrRegister', true]])
);
expect(stdoutData).to.include(
'Enable Serverless Dashboard to get enhanced monitoring, logs and secrets management: https://serverless.com/monitoring'
);
});
it('Should login and skip question when user providers `org` option', async () => {
@ -198,19 +188,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-login.test.js', function
inquirer,
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
await loginStep.run(context);
}
);
await loginStep.run(context);
expect(loginStub.called).to.be.false;
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([['shouldLoginOrRegister', false]])
);
expect(stdoutData).to.include(
'Enable Serverless Dashboard to get enhanced monitoring, logs and secrets management: https://serverless.com/monitoring'
);
});
});

274
test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js
View File

@ -7,10 +7,8 @@ const proxyquire = require('proxyquire');
const fsp = require('fs').promises;
const yaml = require('js-yaml');
const overrideCwd = require('process-utils/override-cwd');
const overrideStdoutWrite = require('process-utils/override-stdout-write');
const overrideEnv = require('process-utils/override-env');
const configureInquirerStub = require('@serverless/test/configure-inquirer-stub');
const stripAnsi = require('strip-ansi');
const { StepHistory } = require('@serverless/utils/telemetry');
const inquirer = require('@serverless/utils/inquirer');
@ -328,16 +326,11 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
inquirer,
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -346,9 +339,6 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('other-app');
expect(context.configuration.org).to.equal('testinteractivecli');
expect(context.configuration.app).to.equal('other-app');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org testinteractivecli and app other-app'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([
['orgName', '_user_choice_'],
@ -373,17 +363,11 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
inquirer,
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideEnv({ variables: { SERVERLESS_ACCESS_KEY: 'validkey' } }, async () => {
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
});
const serviceConfig = yaml.load(
@ -393,9 +377,6 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('other-app');
expect(context.configuration.org).to.equal('fromaccesskey');
expect(context.configuration.app).to.equal('other-app');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org fromaccesskey and app other-app'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([
['orgName', '_user_choice_'],
@ -420,17 +401,11 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
inquirer,
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideEnv({ variables: { SERVERLESS_ACCESS_KEY: 'validkey' } }, async () => {
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
});
const serviceConfig = yaml.load(
@ -600,16 +575,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -618,9 +587,6 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal(configuration.service);
expect(context.configuration.org).to.equal('orgwithoutapps');
expect(context.configuration.app).to.equal(configuration.service);
expect(stripAnsi(stdoutData)).to.include(
`Your project has been setup with org orgwithoutapps and app ${configuration.service}`
);
expect(context.stepHistory.valuesMap()).to.deep.equal(new Map());
});
});
@ -641,16 +607,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -659,9 +619,6 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('other-app');
expect(context.configuration.org).to.equal('testinteractivecli');
expect(context.configuration.app).to.equal('other-app');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org testinteractivecli and app other-app'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(new Map());
});
@ -683,16 +640,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -701,9 +652,6 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('app-from-flag');
expect(context.configuration.org).to.equal('otherorg');
expect(context.configuration.app).to.equal('app-from-flag');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org otherorg and app app-from-flag'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([['shouldOverrideDashboardConfig', true]])
);
@ -758,16 +706,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -776,9 +718,7 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('other-app');
expect(context.configuration.org).to.equal('testinteractivecli');
expect(context.configuration.app).to.equal('other-app');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org testinteractivecli and app other-app'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([
['orgName', '_user_choice_'],
@ -807,16 +747,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -825,9 +759,7 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('other-app');
expect(context.configuration.org).to.equal('otherorg');
expect(context.configuration.app).to.equal('other-app');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org otherorg and app other-app'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([
['orgName', '_user_choice_'],
@ -855,16 +787,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
history: new Map(),
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -873,9 +799,6 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('other-app');
expect(context.configuration.org).to.equal('testinteractivecli');
expect(context.configuration.app).to.equal('other-app');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org testinteractivecli and app other-app'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([
['orgName', '_user_choice_'],
@ -903,16 +826,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -921,9 +838,7 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('other-app');
expect(context.configuration.org).to.equal('testinteractivecli');
expect(context.configuration.app).to.equal('other-app');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org testinteractivecli and app other-app'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([['appName', '_user_choice_']])
);
@ -947,16 +862,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
history: new Map(),
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -965,9 +874,7 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('frominput');
expect(context.configuration.org).to.equal('testinteractivecli');
expect(context.configuration.app).to.equal('frominput');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org testinteractivecli and app frominput'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([
['orgName', '_user_choice_'],
@ -997,16 +904,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
history: new Map(),
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -1015,9 +916,6 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('other-app');
expect(context.configuration.org).to.equal('testinteractivecli');
expect(context.configuration.app).to.equal('other-app');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org testinteractivecli and app other-app'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([
['shouldUpdateOrg', true],
@ -1047,16 +945,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -1065,9 +957,6 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('other-app');
expect(context.configuration.org).to.equal('testinteractivecli');
expect(context.configuration.app).to.equal('other-app');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org testinteractivecli and app other-app'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([['appName', '_user_choice_']])
);
@ -1090,16 +979,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -1108,9 +991,6 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('app-from-flag');
expect(context.configuration.org).to.equal('testinteractivecli');
expect(context.configuration.app).to.equal('app-from-flag');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org testinteractivecli and app app-from-flag'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(new Map());
});
@ -1130,16 +1010,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -1148,9 +1022,6 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal(configuration.service);
expect(context.configuration.org).to.equal('orgwithoutapps');
expect(context.configuration.app).to.equal(configuration.service);
expect(stripAnsi(stdoutData)).to.include(
`Your project has been setup with org orgwithoutapps and app ${configuration.service}`
);
expect(context.stepHistory.valuesMap()).to.deep.equal(new Map());
});
@ -1172,16 +1043,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -1190,9 +1055,6 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('other-app');
expect(context.configuration.org).to.equal('testinteractivecli');
expect(context.configuration.app).to.equal('other-app');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org testinteractivecli and app other-app'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([['appName', '_user_choice_']])
);
@ -1224,16 +1086,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -1242,9 +1098,6 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('not-created-app');
expect(context.configuration.org).to.equal('testinteractivecli');
expect(context.configuration.app).to.equal('not-created-app');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org testinteractivecli and app not-created-app'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([['appUpdateType', '_create_']])
);
@ -1274,16 +1127,10 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
stepHistory: new StepHistory(),
};
let stdoutData = '';
await overrideCwd(serviceDir, async () => {
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
}
);
const stepData = await step.isApplicable(context);
if (!stepData) throw new Error('Step resolved as not applicable');
await step.run(context, stepData);
});
const serviceConfig = yaml.load(
String(await fsp.readFile(join(serviceDir, 'serverless.yml')))
@ -1292,9 +1139,6 @@ describe('test/unit/lib/cli/interactive-setup/dashboard-set-org.test.js', functi
expect(serviceConfig.app).to.equal('other-app');
expect(context.configuration.org).to.equal('testinteractivecli');
expect(context.configuration.app).to.equal('other-app');
expect(stripAnsi(stdoutData)).to.include(
'Your project has been setup with org testinteractivecli and app other-app'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([
['appUpdateType', '_choose_existing_'],

80
test/unit/lib/cli/interactive-setup/deploy.test.js
View File

@ -1,13 +1,11 @@
'use strict';
const stripAnsi = require('strip-ansi');
const chai = require('chai');
const sinon = require('sinon');
const configureInquirerStub = require('@serverless/test/configure-inquirer-stub');
const overrideEnv = require('process-utils/override-env');
const step = require('../../../../../lib/cli/interactive-setup/deploy');
const proxyquire = require('proxyquire');
const overrideStdoutWrite = require('process-utils/override-stdout-write');
const { StepHistory } = require('@serverless/utils/telemetry');
const { expect } = chai;
@ -89,16 +87,8 @@ describe('test/unit/lib/cli/interactive-setup/deploy.test.js', () => {
isInServiceContext: false,
},
};
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => await step.run(context)
);
await step.run(context);
expect(stripAnsi(stdoutData)).to.include(
'Your project is ready for deployment and available in'
);
expect(stripAnsi(stdoutData)).to.include('Run serverless in the project directory');
expect(context.stepHistory.valuesMap()).to.deep.equal(new Map([['shouldDeploy', false]]));
});
@ -119,14 +109,8 @@ describe('test/unit/lib/cli/interactive-setup/deploy.test.js', () => {
isInServiceContext: true,
},
};
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => await step.run(context)
);
await step.run(context);
expect(stripAnsi(stdoutData)).to.include('Your project is ready for deployment\n');
expect(stripAnsi(stdoutData)).to.include('Run serverless in the project directory');
expect(context.stepHistory.valuesMap()).to.deep.equal(new Map([['shouldDeploy', false]]));
});
@ -149,18 +133,8 @@ describe('test/unit/lib/cli/interactive-setup/deploy.test.js', () => {
isInServiceContext: false,
},
};
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => await step.run(context)
);
await step.run(context);
expect(stripAnsi(stdoutData)).to.include(
'Your project is ready for deployment and available in'
);
expect(stripAnsi(stdoutData)).to.include(
'Invoke your functions and view logs in the dashboard'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(new Map([['shouldDeploy', false]]));
});
@ -183,16 +157,8 @@ describe('test/unit/lib/cli/interactive-setup/deploy.test.js', () => {
isInServiceContext: true,
},
};
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => await step.run(context)
);
await step.run(context);
expect(stripAnsi(stdoutData)).to.include('Your project is ready for deployment\n');
expect(stripAnsi(stdoutData)).to.include(
'Invoke your functions and view logs in the dashboard'
);
expect(context.stepHistory.valuesMap()).to.deep.equal(new Map([['shouldDeploy', false]]));
});
@ -243,16 +209,7 @@ describe('test/unit/lib/cli/interactive-setup/deploy.test.js', () => {
isInServiceContext: false,
},
};
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => await mockedStep.run(context)
);
expect(stripAnsi(stdoutData)).to.include('Your project is live and available');
expect(stripAnsi(stdoutData)).to.include(
'Open https://app.serverless-dev.com/path/to/dashboard'
);
await mockedStep.run(context);
expect(context.stepHistory.valuesMap()).to.deep.equal(new Map([['shouldDeploy', true]]));
});
@ -304,16 +261,7 @@ describe('test/unit/lib/cli/interactive-setup/deploy.test.js', () => {
isInServiceContext: true,
},
};
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => await mockedStep.run(context)
);
expect(stripAnsi(stdoutData)).to.include('Your project is live\n');
expect(stripAnsi(stdoutData)).to.include(
'Open https://app.serverless-dev.com/path/to/dashboard'
);
await mockedStep.run(context);
expect(context.stepHistory.valuesMap()).to.deep.equal(new Map([['shouldDeploy', true]]));
});
@ -359,14 +307,8 @@ describe('test/unit/lib/cli/interactive-setup/deploy.test.js', () => {
isInServiceContext: false,
},
};
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => await mockedStep.run(context)
);
await mockedStep.run(context);
expect(stripAnsi(stdoutData)).to.include('Your project is live and available');
expect(stripAnsi(stdoutData)).to.include('Run serverless');
expect(context.stepHistory.valuesMap()).to.deep.equal(new Map([['shouldDeploy', true]]));
});
@ -411,14 +353,8 @@ describe('test/unit/lib/cli/interactive-setup/deploy.test.js', () => {
isInServiceContext: true,
},
};
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => await mockedStep.run(context)
);
await mockedStep.run(context);
expect(stripAnsi(stdoutData)).to.include('Your project is live\n');
expect(stripAnsi(stdoutData)).to.include('Run serverless');
expect(context.stepHistory.valuesMap()).to.deep.equal(new Map([['shouldDeploy', true]]));
});
});

46
test/unit/lib/cli/interactive-setup/service.test.js
View File

@ -6,7 +6,6 @@ const sinon = require('sinon');
const configureInquirerStub = require('@serverless/test/configure-inquirer-stub');
const step = require('../../../../../lib/cli/interactive-setup/service');
const proxyquire = require('proxyquire');
const overrideStdoutWrite = require('process-utils/override-stdout-write');
const ServerlessError = require('../../../../../lib/serverless-error');
const { StepHistory } = require('@serverless/utils/telemetry');
@ -208,51 +207,6 @@ describe('test/unit/lib/cli/interactive-setup/service.test.js', () => {
);
});
it('Should emit warning if npm installation not found', async () => {
const downloadTemplateFromRepoStub = sinon.stub();
const mockedStep = proxyquire('../../../../../lib/cli/interactive-setup/service', {
'child-process-ext/spawn': sinon.stub().rejects({ code: 'ENOENT' }),
'../../utils/downloadTemplateFromRepo': {
downloadTemplateFromRepo: downloadTemplateFromRepoStub.callsFake(
async (templateUrl, projectType, projectName) => {
await fsp.mkdir(projectName);
const serverlessYmlContent = `
service: service
provider:
name: aws
`;
await fsp.writeFile(path.join(projectName, 'serverless.yml'), serverlessYmlContent);
await fsp.writeFile(path.join(projectName, 'package.json'), '{}');
}
),
},
});
configureInquirerStub(inquirer, {
list: { projectType: 'aws-nodejs' },
input: { projectName: 'test-project-missing-npm' },
});
const context = { options: {}, stepHistory: new StepHistory() };
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => mockedStep.run(context)
);
const stats = await fsp.lstat('test-project-missing-npm/serverless.yml');
expect(stats.isFile()).to.be.true;
expect(stdoutData).to.include('Cannot install dependencies');
expect(context.stepHistory.valuesMap()).to.deep.equal(
new Map([
['projectType', 'aws-nodejs'],
['projectName', '_user_input_'],
])
);
});
it('Should emit warning if npm installation not found', async () => {
const downloadTemplateFromRepoStub = sinon.stub();
const mockedStep = proxyquire('../../../../../lib/cli/interactive-setup/service', {

34
test/unit/lib/cli/render-help/command.test.js
View File

@ -1,31 +1,23 @@
'use strict';
const { expect } = require('chai');
const overrideStdoutWrite = require('process-utils/override-stdout-write');
const renderCommandHelp = require('../../../../../lib/cli/render-help/command');
const commandsSchema = require('../../../../../lib/cli/commands-schema');
const observeOutput = require('@serverless/test/observe-output');
describe('test/unit/lib/cli/render-help/command.test.js', () => {
it('should show help', () => {
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => renderCommandHelp('deploy')
);
expect(stdoutData).to.have.string('deploy');
expect(stdoutData).to.have.string('deploy function');
expect(stdoutData).to.have.string('--help');
expect(stdoutData).to.have.string(commandsSchema.get('deploy').usage);
expect(stdoutData).to.have.string(commandsSchema.get('deploy function').usage);
it('should show help', async () => {
const output = await observeOutput(() => renderCommandHelp('deploy'));
expect(output).to.have.string('deploy');
expect(output).to.have.string('deploy function');
expect(output).to.have.string('--help');
expect(output).to.have.string(commandsSchema.get('deploy').usage);
expect(output).to.have.string(commandsSchema.get('deploy function').usage);
});
it('should show help for container command', () => {
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => renderCommandHelp('config tabcompletion')
);
expect(stdoutData).to.have.string('config tabcompletion install');
expect(stdoutData).to.have.string(commandsSchema.get('config tabcompletion install').usage);
expect(stdoutData).to.have.string(commandsSchema.get('config tabcompletion uninstall').usage);
it('should show help for container command', async () => {
const output = await observeOutput(() => renderCommandHelp('config tabcompletion'));
expect(output).to.have.string('config tabcompletion install');
expect(output).to.have.string(commandsSchema.get('config tabcompletion install').usage);
expect(output).to.have.string(commandsSchema.get('config tabcompletion uninstall').usage);
});
});

14
test/unit/lib/cli/render-help/general.test.js
View File

@ -1,17 +1,13 @@
'use strict';
const { expect } = require('chai');
const overrideStdoutWrite = require('process-utils/override-stdout-write');
const renderGeneralHelp = require('../../../../../lib/cli/render-help/general');
const observeOutput = require('@serverless/test/observe-output');
describe('test/unit/lib/cli/render-help/general.test.js', () => {
it('should show help', () => {
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => renderGeneralHelp(new Set())
);
expect(stdoutData).to.have.string('General Commands');
expect(stdoutData).to.have.string('deploy function');
it('should show help', async () => {
const output = await observeOutput(() => renderGeneralHelp(new Set()));
expect(output).to.have.string('Usage');
expect(output).to.have.string('deploy function');
});
});

56
test/unit/lib/cli/render-help/index.test.js
View File

@ -3,11 +3,11 @@
const { expect } = require('chai');
const overrideArgv = require('process-utils/override-argv');
const resolveInput = require('../../../../../lib/cli/resolve-input');
const overrideStdoutWrite = require('process-utils/override-stdout-write');
const renderHelp = require('../../../../../lib/cli/render-help');
const observeOutput = require('@serverless/test/observe-output');
describe('test/unit/lib/cli/render-help/index.test.js', () => {
it('should show general help on main command', () => {
it('should show general help on main command', async () => {
resolveInput.clear();
overrideArgv(
{
@ -15,16 +15,12 @@ describe('test/unit/lib/cli/render-help/index.test.js', () => {
},
() => resolveInput()
);
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => renderHelp(new Set())
);
expect(stdoutData).to.have.string('General Commands');
expect(stdoutData).to.have.string('deploy function');
const output = await observeOutput(() => renderHelp(new Set()));
expect(output).to.have.string('Usage');
expect(output).to.have.string('deploy function');
});
it('should show interactive help when requested', () => {
it('should show interactive help when requested', async () => {
resolveInput.clear();
overrideArgv(
{
@ -32,16 +28,12 @@ describe('test/unit/lib/cli/render-help/index.test.js', () => {
},
() => resolveInput()
);
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => renderHelp(new Set())
);
expect(stdoutData).to.have.string('Interactive CLI');
expect(stdoutData).to.have.string('--help-interactive');
const output = await observeOutput(() => renderHelp(new Set()));
expect(output).to.have.string('Interactive CLI');
expect(output).to.have.string('--help-interactive');
});
it('should show general help on help command', () => {
it('should show general help on help command', async () => {
resolveInput.clear();
overrideArgv(
{
@ -49,16 +41,12 @@ describe('test/unit/lib/cli/render-help/index.test.js', () => {
},
() => resolveInput()
);
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => renderHelp(new Set())
);
expect(stdoutData).to.have.string('General Commands');
expect(stdoutData).to.have.string('deploy function');
const output = await observeOutput(() => renderHelp(new Set()));
expect(output).to.have.string('Usage');
expect(output).to.have.string('deploy function');
});
it('should show specific commmand help with specific command', () => {
it('should show specific commmand help with specific command', async () => {
resolveInput.clear();
const { commandsSchema } = overrideArgv(
{
@ -66,15 +54,11 @@ describe('test/unit/lib/cli/render-help/index.test.js', () => {
},
() => resolveInput()
);
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => renderHelp(new Set())
);
expect(stdoutData).to.have.string('deploy');
expect(stdoutData).to.have.string('deploy function');
expect(stdoutData).to.have.string('--help');
expect(stdoutData).to.have.string(commandsSchema.get('deploy').usage);
expect(stdoutData).to.have.string(commandsSchema.get('deploy function').usage);
const output = await observeOutput(() => renderHelp(new Set()));
expect(output).to.have.string('deploy');
expect(output).to.have.string('deploy function');
expect(output).to.have.string('--help');
expect(output).to.have.string(commandsSchema.get('deploy').usage);
expect(output).to.have.string(commandsSchema.get('deploy function').usage);
});
});

14
test/unit/lib/cli/render-help/interactive-setup.test.js
View File

@ -1,17 +1,13 @@
'use strict';
const { expect } = require('chai');
const overrideStdoutWrite = require('process-utils/override-stdout-write');
const renderInteractiveSetupHelp = require('../../../../../lib/cli/render-help/interactive-setup');
const observeOutput = require('@serverless/test/observe-output');
describe('test/unit/lib/cli/render-help/interactive-setup.test.js', () => {
it('should show help', () => {
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => renderInteractiveSetupHelp()
);
expect(stdoutData).to.have.string('Interactive CLI');
expect(stdoutData).to.have.string('--help-interactive');
it('should show help', async () => {
const output = await observeOutput(() => renderInteractiveSetupHelp());
expect(output).to.have.string('Interactive CLI');
expect(output).to.have.string('--help-interactive');
});
});

37
test/unit/lib/cli/render-help/options.test.js
View File

@ -1,29 +1,26 @@
'use strict';
const { expect } = require('chai');
const overrideStdoutWrite = require('process-utils/override-stdout-write');
const renderOptionsHelp = require('../../../../../lib/cli/render-help/options');
const observeOutput = require('@serverless/test/observe-output');
describe('test/unit/lib/cli/render-help/options.test.js', () => {
it('should list options', () => {
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() =>
renderOptionsHelp({
foo: {
usage: 'Some option',
shortcut: 'b',
required: true,
},
bar: {
usage: 'Elo',
},
noData: {},
})
it('should list options', async () => {
const output = await observeOutput(() =>
renderOptionsHelp({
foo: {
usage: 'Some option',
shortcut: 'b',
required: true,
},
bar: {
usage: 'Elo',
},
noData: {},
})
);
expect(stdoutData).to.have.string('--foo');
expect(stdoutData).to.have.string('-b');
expect(stdoutData).to.have.string('Some option');
expect(output).to.have.string('--foo');
expect(output).to.have.string('-b');
expect(output).to.have.string('Some option');
});
});

12
test/unit/lib/cli/render-version.test.js
View File

@ -1,17 +1,13 @@
'use strict';
const { expect } = require('chai');
const overrideStdoutWrite = require('process-utils/override-stdout-write');
const listVersion = require('../../../../lib/cli/render-version');
const observeOutput = require('@serverless/test/observe-output');
describe('test/unit/lib/cli/list-version.test.js', () => {
it('should log version', async () => {
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
() => listVersion()
);
expect(stdoutData).to.have.string('Framework Core: ');
expect(stdoutData).to.have.string('SDK: ');
const output = await observeOutput(() => listVersion());
expect(output).to.have.string('Framework Core: ');
expect(output).to.have.string('SDK: ');
});
});

4
test/unit/lib/configSchema.test.js
View File

@ -63,7 +63,6 @@ describe('test/unit/lib/configSchema.test.js', () => {
},
{
isValid: true,
logMessage: 'Unrecognized provider',
description: 'provider not existing name',
mutation: {
provider: { name: 'awssss' },
@ -93,11 +92,10 @@ describe('test/unit/lib/configSchema.test.js', () => {
configExt: someCase.mutation,
command: 'info',
}).then(
({ stdoutData }) => {
() => {
if (!someCase.isValid) {
expect(false).to.be.true;
}
if (someCase.logMessage) expect(stdoutData).to.include(someCase.logMessage);
return;
},
(err) => {

25
test/unit/lib/plugins/aws/deploy/lib/checkForChanges.test.js
View File

@ -1071,31 +1071,6 @@ describe('test/unit/lib/plugins/aws/deploy/lib/checkForChanges.test.js', () => {
expect(serverless.service.provider.shouldNotDeploy).to.equal(true);
});
it('should print a warning if missing lambda:GetFunction permission', async () => {
const { stdoutData } = await runServerless({
fixture: 'checkForChanges',
command: 'deploy',
lastLifecycleHookName: 'aws:deploy:deploy:checkForChanges',
awsRequestStubMap: {
...commonAwsSdkMock,
Lambda: {
getFunction: sandbox.stub().throws({ providerError: { statusCode: 403 } }),
},
S3: {
listObjectsV2: {},
headObjects: {},
headBucket: {},
},
},
});
expect(stdoutData).to.include(
[
'WARNING: Not authorized to perform: lambda:GetFunction for at least one of the lambda functions.',
' Deployment will not be skipped even if service files did not change.',
].join('')
);
});
it.skip('TODO: should crash meaningfully if bucket does not exist', () => {
// Replaces:
// https://github.com/serverless/serverless/blob/11fb14115ea47d53a61fa666a94e60d585fb3a4d/test/unit/lib/plugins/aws/deploy/lib/checkForChanges.test.js#L137-L149

44
test/unit/lib/plugins/aws/deploy/lib/extendedValidate.test.js
View File

@ -7,7 +7,6 @@ const AwsProvider = require('../../../../../../../lib/plugins/aws/provider');
const AwsDeploy = require('../../../../../../../lib/plugins/aws/deploy/index');
const Serverless = require('../../../../../../../lib/Serverless');
const { getTmpDirPath } = require('../../../../../../utils/fs');
const runServerless = require('../../../../../../utils/run-serverless');
chai.use(require('sinon-chai'));
@ -165,46 +164,3 @@ describe('extendedValidate', () => {
});
});
});
describe('test/unit/lib/plugins/aws/deploy/lib/extendedValidate.test.js', () => {
it("should not warn if function's timeout is greater than 30 and it's attached to APIGW, but it has [async] mode", async () => {
const msg = [
"WARNING: Function foo has timeout of 31 seconds, however, it's",
"attached to API Gateway so it's automatically limited to 30 seconds.",
].join(' ');
const { stdoutData } = await runServerless({
fixture: 'function',
configExt: {
functions: {
basic: {
timeout: 31,
events: [
{
http: {
method: 'GET',
path: '/foo',
async: true,
},
},
],
},
},
},
awsRequestStubMap: {
STS: {
getCallerIdentity: {
ResponseMetadata: { RequestId: 'ffffffff-ffff-ffff-ffff-ffffffffffff' },
UserId: 'XXXXXXXXXXXXXXXXXXXXX',
Account: '1234567890',
Arn: 'arn:aws:iam::1234567890:user/test',
},
},
},
command: 'deploy',
lastLifecycleHookName: 'before:deploy:deploy',
});
expect(stdoutData.includes(msg)).to.be.equal(false);
});
});

25
test/unit/lib/plugins/aws/deployFunction.test.js
View File

@ -398,7 +398,7 @@ describe('test/unit/lib/plugins/aws/deployFunction.test.js', () => {
});
it('should skip updating function configuration if image config did not change', async () => {
const { stdoutData } = await runServerless({
await runServerless({
fixture: 'function',
command: 'deploy function',
options: { function: 'basic' },
@ -439,13 +439,10 @@ describe('test/unit/lib/plugins/aws/deployFunction.test.js', () => {
},
});
expect(updateFunctionConfigurationStub).not.to.be.called;
expect(stdoutData).to.include(
'Configuration did not change. Skipping function configuration update.'
);
});
it('should skip deployment if image sha did not change', async () => {
const { stdoutData } = await runServerless({
await runServerless({
fixture: 'function',
command: 'deploy function',
options: { function: 'basic' },
@ -472,7 +469,6 @@ describe('test/unit/lib/plugins/aws/deployFunction.test.js', () => {
},
});
expect(updateFunctionCodeStub).not.to.be.called;
expect(stdoutData).to.include('Image did not change. Skipping function deployment.');
});
it('should fail if function with image was previously defined with handler', async () => {
@ -543,7 +539,7 @@ describe('test/unit/lib/plugins/aws/deployFunction.test.js', () => {
.throws({ providerError: { code: 'ResourceConflictException' } })
.onSecondCall()
.resolves({});
const { stdoutData } = await runServerless({
await runServerless({
fixture: 'function',
command: 'deploy function',
options: { function: 'basic' },
@ -566,12 +562,11 @@ describe('test/unit/lib/plugins/aws/deployFunction.test.js', () => {
},
});
expect(stdoutData).to.include('Retrying configuration update for function');
expect(innerUpdateFunctionConfigurationStub.callCount).to.equal(2);
});
it('should update function configuration if configuration changed', async () => {
const { stdoutData } = await runServerless({
await runServerless({
fixture: 'function',
command: 'deploy function',
options: { function: 'basic' },
@ -641,11 +636,10 @@ describe('test/unit/lib/plugins/aws/deployFunction.test.js', () => {
},
Layers: [layerArn, secondLayerArn],
});
expect(stdoutData).to.include('Successfully updated function');
});
it('should skip updating properties that contain references', async () => {
const { stdoutData } = await runServerless({
await runServerless({
fixture: 'function',
command: 'deploy function',
options: { function: 'basic' },
@ -692,11 +686,10 @@ describe('test/unit/lib/plugins/aws/deployFunction.test.js', () => {
},
Role: role,
});
expect(stdoutData).to.include('Successfully updated function');
});
it('should update function configuration with provider-level properties', async () => {
const { stdoutData } = await runServerless({
await runServerless({
fixture: 'function',
command: 'deploy function',
options: { function: 'basic' },
@ -753,11 +746,10 @@ describe('test/unit/lib/plugins/aws/deployFunction.test.js', () => {
SubnetIds: ['subnet-111', 'subnet-222'],
},
});
expect(stdoutData).to.include('Successfully updated function');
});
it('should not update function configuration if configuration did not change', async () => {
const { stdoutData } = await runServerless({
await runServerless({
fixture: 'function',
command: 'deploy function',
options: { function: 'basic' },
@ -828,9 +820,6 @@ describe('test/unit/lib/plugins/aws/deployFunction.test.js', () => {
});
expect(updateFunctionConfigurationStub).not.to.be.called;
expect(stdoutData).to.include(
'Configuration did not change. Skipping function configuration update.'
);
});
it('configuration uses the "kmsKeyArn" instead of functionObj.awsKmsKeyArn', async () => {

4
test/unit/lib/plugins/aws/invoke.test.js
View File

@ -63,9 +63,7 @@ describe('test/unit/lib/plugins/aws/invoke.test.js', () => {
});
it('should log payload', () => {
expect(result.stdoutData).to.contain(
'{\n "inputKey": "inputValue"\n}\n\u001b[90m--------------------------------------------------------------------\u001b[39m\ntest\n'
);
expect(result.output).to.contain('"inputKey": "inputValue"');
});
});

62
test/unit/lib/plugins/aws/invokeLocal/index.test.js
View File

@ -970,7 +970,7 @@ describe('test/unit/lib/plugins/aws/invokeLocal/index.test.js', () => {
process.env.AWS_ACCESS_KEY_ID = 'AAKIXXX';
process.env.AWS_SECRET_ACCESS_KEY = 'ASAKXXX';
// Confirm outcome on { stdout }
// Confirm outcome on { output }
const response = await runServerless({
fixture: 'invocation',
command: 'invoke local',
@ -997,8 +997,8 @@ describe('test/unit/lib/plugins/aws/invokeLocal/index.test.js', () => {
},
},
});
const stdoutAsJson = JSON.parse(response.stdoutData);
responseBody = JSON.parse(stdoutAsJson.body);
const outputAsJson = JSON.parse(response.output);
responseBody = JSON.parse(outputAsJson.body);
});
after(() => {
@ -1046,33 +1046,33 @@ describe('test/unit/lib/plugins/aws/invokeLocal/index.test.js', () => {
testRuntime('callback');
it('should support success resolution via async function', async () => {
const { stdoutData } = await runServerless({
const { output } = await runServerless({
fixture: 'invocation',
command: 'invoke local',
options: { function: 'async' },
});
expect(stdoutData).to.include('Invoked');
expect(output).to.include('Invoked');
});
it('should support success resolution via context.done', async () => {
const { stdoutData } = await runServerless({
const { output } = await runServerless({
fixture: 'invocation',
command: 'invoke local',
options: { function: 'contextDone' },
});
expect(stdoutData).to.include('Invoked');
expect(output).to.include('Invoked');
});
it('should support success resolution via context.succeed', async () => {
const { stdoutData } = await runServerless({
const { output } = await runServerless({
fixture: 'invocation',
command: 'invoke local',
options: { function: 'contextSucceed' },
});
expect(stdoutData).to.include('Invoked');
expect(output).to.include('Invoked');
});
it('should support immediate failure at initialization', async () => {
@ -1099,69 +1099,69 @@ describe('test/unit/lib/plugins/aws/invokeLocal/index.test.js', () => {
});
it('should support failure resolution via async function', async () => {
const { stdoutData } = await runServerless({
const { output } = await runServerless({
fixture: 'invocation',
command: 'invoke local',
options: { function: 'async', data: '{"shouldFail":true}' },
});
expect(stdoutData).to.include('Failed on request');
expect(output).to.include('Failed on request');
});
it('should support failure resolution via callback', async () => {
const { stdoutData } = await runServerless({
const { output } = await runServerless({
fixture: 'invocation',
command: 'invoke local',
options: { function: 'callback', data: '{"shouldFail":true}' },
});
expect(stdoutData).to.include('Failed on request');
expect(output).to.include('Failed on request');
});
it('should support failure resolution via context.done', async () => {
const { stdoutData } = await runServerless({
const { output } = await runServerless({
fixture: 'invocation',
command: 'invoke local',
options: { function: 'contextDone', data: '{"shouldFail":true}' },
});
expect(stdoutData).to.include('Failed on request');
expect(output).to.include('Failed on request');
});
it('should support failure resolution via context.fail', async () => {
const { stdoutData } = await runServerless({
const { output } = await runServerless({
fixture: 'invocation',
command: 'invoke local',
options: { function: 'contextSucceed', data: '{"shouldFail":true}' },
});
expect(stdoutData).to.include('Failed on request');
expect(output).to.include('Failed on request');
});
it('should recognize first resolution', async () => {
const { stdoutData: firstRunStdout } = await runServerless({
const { output: firstRunOutput } = await runServerless({
fixture: 'invocation',
command: 'invoke local',
options: { function: 'doubledResolutionCallbackFirst' },
});
const { stdoutData: secondRunStdout } = await runServerless({
const { output: secondRunOutput } = await runServerless({
fixture: 'invocation',
command: 'invoke local',
options: { function: 'doubledResolutionPromiseFirst' },
});
expect(firstRunStdout).to.include('callback');
expect(secondRunStdout).to.include('promise');
expect(firstRunOutput).to.include('callback');
expect(secondRunOutput).to.include('promise');
});
it('should support context.remainingTimeInMillis()', async () => {
const { stdoutData } = await runServerless({
const { output } = await runServerless({
fixture: 'invocation',
command: 'invoke local',
options: { function: 'remainingTime' },
});
const body = JSON.parse(stdoutData).body;
const body = JSON.parse(output).body;
const [firstRemainingMs, secondRemainingMs, thirdRemainingMs] = JSON.parse(body).data;
expect(firstRemainingMs).to.be.lte(3000);
expect(secondRemainingMs).to.be.lte(2910);
@ -1182,13 +1182,13 @@ describe('test/unit/lib/plugins/aws/invokeLocal/index.test.js', () => {
testRuntime('python');
describe('context.remainingTimeInMillis', () => {
it('should support context.get_remaining_time_in_millis()', async () => {
const { stdoutData } = await runServerless({
const { output } = await runServerless({
fixture: 'invocation',
command: 'invoke local',
options: { function: 'pythonRemainingTime' },
});
const { start, stop } = JSON.parse(stdoutData);
const { start, stop } = JSON.parse(output);
expect(start).to.lte(3000);
expect(stop).to.lte(2910);
});
@ -1208,33 +1208,33 @@ describe('test/unit/lib/plugins/aws/invokeLocal/index.test.js', () => {
testRuntime('ruby');
it('should support class/module address in handler for "ruby*" runtime', async () => {
const { stdoutData } = await runServerless({
const { output } = await runServerless({
fixture: 'invocation',
command: 'invoke local',
options: { function: 'rubyClass' },
});
expect(stdoutData).to.include('rubyclass');
expect(output).to.include('rubyclass');
});
it('should support context.get_remaining_time_in_millis()', async () => {
const { stdoutData } = await runServerless({
const { output } = await runServerless({
fixture: 'invocation',
command: 'invoke local',
options: { function: 'rubyRemainingTime' },
});
const { start, stop } = JSON.parse(stdoutData);
const { start, stop } = JSON.parse(output);
expect(start).to.lte(6000);
expect(stop).to.lte(5910);
});
it('should support context.deadline_ms', async () => {
const { stdoutData } = await runServerless({
const { output } = await runServerless({
fixture: 'invocation',
command: 'invoke local',
options: { function: 'rubyDeadline' },
});
const { deadlineMs } = JSON.parse(stdoutData);
const { deadlineMs } = JSON.parse(output);
expect(deadlineMs).to.be.gt(Date.now());
});
});

3
test/unit/lib/plugins/aws/package/compile/functions.test.js
View File

@ -2582,7 +2582,7 @@ describe('lib/plugins/aws/package/compile/functions/index.test.js', () => {
const originalVersionArn =
originalTemplate.Outputs.BasicLambdaFunctionQualifiedArn.Value.Ref;
const { cfTemplate: updatedTemplate, stdoutData } = await runServerless({
const { cfTemplate: updatedTemplate } = await runServerless({
cwd: serviceDir,
command: 'deploy',
lastLifecycleHookName: 'before:deploy:deploy',
@ -2596,7 +2596,6 @@ describe('lib/plugins/aws/package/compile/functions/index.test.js', () => {
expect(
updatedTemplate.Resources[awsNaming.getLambdaLogicalId('basic')].Properties.Description
).to.equal('temporary-description-to-enforce-hash-update');
expect(stdoutData).to.include('Your service has been deployed with new hashing algorithm');
});
});
});

35
test/unit/lib/plugins/aws/provider.test.js
View File

@ -1501,41 +1501,6 @@ aws_secret_access_key = CUSTOMSECRET
]);
});
it('should emit warning if docker login stores unencrypted credentials', async () => {
const awsRequestStubMap = {
...baseAwsRequestStubMap,
ECR: {
...baseAwsRequestStubMap.ECR,
describeRepositories: describeRepositoriesStub.resolves({
repositories: [{ repositoryUri }],
}),
createRepository: createRepositoryStub,
},
};
const { stdoutData } = await runServerless({
fixture: 'ecr',
command: 'package',
awsRequestStubMap,
modulesCacheStub: {
...modulesCacheStub,
'child-process-ext/spawn': sinon
.stub()
.returns({
stdBuffer: `digest: sha256:${imageSha} size: 1787`,
})
.onCall(3)
.throws({ stdBuffer: 'no basic auth credentials' })
.onCall(4)
.returns({ stdBuffer: 'your password will be stored unencrypted' }),
},
});
expect(stdoutData).to.include(
'WARNING: Docker authentication token will be stored unencrypted in docker config.'
);
});
it('should work correctly when image is defined with implicit path in provider', async () => {
const awsRequestStubMap = {
...baseAwsRequestStubMap,

15
test/unit/lib/plugins/aws/remove/index.test.js
View File

@ -212,21 +212,6 @@ describe('test/unit/lib/plugins/aws/remove/index.test.js', () => {
});
});
it('emits warning when repository cannot be accessed due to denied access but there are images defined', async () => {
describeRepositoriesStub.throws({ providerError: { code: 'AccessDeniedException' } });
const { stdoutData } = await runServerless({
fixture: 'ecr',
command: 'remove',
awsRequestStubMap,
});
expect(stdoutData).to.include('WARNING: Could not access ECR repository due to denied access');
expect(stdoutData).to.include('ECR repository removal will be skipped.');
expect(deleteRepositoryStub).not.to.be.called;
});
it('should execute expected operations with versioning enabled if no object versions are present', async () => {
const listObjectVersionsStub = sinon.stub().resolves();

4
test/unit/lib/plugins/print.test.js
View File

@ -10,11 +10,11 @@ const expect = chai.expect;
describe('test/unit/lib/plugins/print.test.js', () => {
it('correctly prints config', async () => {
const { stdoutData } = await runServerless({
const { output } = await runServerless({
fixture: 'aws',
command: 'print',
});
expect(stdoutData).to.include('name: aws');
expect(output).to.include('name: aws');
});
});

137
test/unit/lib/utils/logDeprecation.test.js
View File

@ -3,17 +3,14 @@
const sandbox = require('sinon');
const expect = require('chai').expect;
const overrideEnv = require('process-utils/override-env');
const overrideStdoutWrite = require('process-utils/override-stdout-write');
const runServerless = require('../../../utils/run-serverless');
const ServerlessError = require('../../../../lib/serverless-error');
describe('test/unit/lib/utils/logDeprecation.test.js', () => {
let restoreEnv;
let originalEnv;
beforeEach(() => {
delete require.cache[require.resolve('../../../../lib/utils/logDeprecation')];
({ originalEnv, restoreEnv } = overrideEnv({
({ restoreEnv } = overrideEnv({
whitelist: ['APPDATA', 'HOME', 'PATH', 'TEMP', 'TMP', 'TMPDIR', 'USERPROFILE'],
}));
});
@ -23,88 +20,6 @@ describe('test/unit/lib/utils/logDeprecation.test.js', () => {
restoreEnv();
});
it('should log deprecation message if not disabled and first time', () => {
const logDeprecation = require('../../../../lib/utils/logDeprecation');
logDeprecation.defaultMode = 'warn';
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => logDeprecation('CODE1', 'Start using deprecation log')
);
expect(stdoutData).to.include('Start using deprecation log');
expect(stdoutData).to.include('Deprecation warning');
expect(stdoutData).to.include('https://www.serverless.com/framework/docs/deprecations/#CODE1');
});
it('should not log deprecation if disabled in env.SLS_DEPRECATION_DISABLE', () => {
process.env.SLS_DEPRECATION_DISABLE = 'CODE1';
const logDeprecation = require('../../../../lib/utils/logDeprecation');
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => logDeprecation('CODE1', 'Start using deprecation log')
);
expect(stdoutData).to.equal('');
});
it('should not log deprecation if disabled in serviceConfig', () => {
// We need original process env variables for npm-conf
Object.assign(process.env, originalEnv);
const logDeprecation = require('../../../../lib/utils/logDeprecation');
return runServerless({
fixture: 'function',
configExt: { disabledDeprecations: ['CODE1'] },
command: 'package',
}).then(({ serverless }) => {
const serviceConfig = serverless.service;
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => logDeprecation('CODE1', 'Start using deprecation log', { serviceConfig })
);
expect(stdoutData).to.equal('');
});
});
it('should not log deprecation if disabled by wildcard in env', () => {
process.env.SLS_DEPRECATION_DISABLE = '*';
const logDeprecation = require('../../../../lib/utils/logDeprecation');
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => logDeprecation('CODE1', 'Start using deprecation log')
);
expect(stdoutData).to.equal('');
});
it('should not log deprecation if disabled by wildcard in service config', () => {
Object.assign(process.env, originalEnv);
const logDeprecation = require('../../../../lib/utils/logDeprecation');
return runServerless({
fixture: 'function',
configExt: { disabledDeprecations: '*' },
command: 'package',
}).then(({ serverless }) => {
const serviceConfig = serverless.service;
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => logDeprecation('CODE1', 'Start using deprecation log', { serviceConfig })
);
expect(stdoutData).to.equal('');
});
});
it('should throw on deprecation if env.SLS_DEPRECATION_NOTIFICATION_MODE=error', () => {
process.env.SLS_DEPRECATION_NOTIFICATION_MODE = 'error';
const logDeprecation = require('../../../../lib/utils/logDeprecation');
expect(() => logDeprecation('CODE1', 'Start using deprecation log'))
.to.throw(ServerlessError)
.with.property('code', 'REJECTED_DEPRECATION_CODE1');
});
it('should throw on deprecation if error notifications mode set in service config', () => {
const logDeprecation = require('../../../../lib/utils/logDeprecation');
expect(() =>
@ -115,54 +30,4 @@ describe('test/unit/lib/utils/logDeprecation.test.js', () => {
.to.throw(ServerlessError)
.with.property('code', 'REJECTED_DEPRECATION_CODE1');
});
it('should not log deprecation twice', () => {
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => {
const logDeprecation = require('../../../../lib/utils/logDeprecation');
logDeprecation.defaultMode = 'warn';
logDeprecation('CODE1', 'Start using deprecation log');
expect(stdoutData).to.include('Start using deprecation log');
stdoutData = '';
logDeprecation('CODE1', 'Start using deprecation log');
}
);
expect(stdoutData).to.equal('');
});
it('should expose working `flushBuffered` method', () => {
let stdoutData = '';
overrideStdoutWrite(
(data) => (stdoutData += data),
() => {
const logDeprecation = require('../../../../lib/utils/logDeprecation');
logDeprecation('CODE1', 'First deprecation');
expect(stdoutData).to.not.include('First deprecation');
logDeprecation('CODE2', 'Second deprecation');
expect(stdoutData).to.not.include('Second deprecation');
logDeprecation.flushBuffered();
}
);
expect(stdoutData).to.include('First deprecation');
expect(stdoutData).to.include('Second deprecation');
});
it('should expose working `printSummary` method', async () => {
let stdoutData = '';
await overrideStdoutWrite(
(data) => (stdoutData += data),
async () => {
const logDeprecation = require('../../../../lib/utils/logDeprecation');
logDeprecation('CODE1', 'First deprecation');
expect(stdoutData).to.not.include('First deprecation');
logDeprecation('CODE2', 'Second deprecation');
expect(stdoutData).to.not.include('Second deprecation');
await logDeprecation.printSummary();
}
);
expect(stdoutData).to.include('First deprecation');
expect(stdoutData).to.include('Second deprecation');
});
});