serverless-ssm-publish/build/util.test.js

Serverless Framework plugin to publish data to AWS SSM Parameter Store

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var util_1 = require("./util");
var throwFunction = function (message) { throw new Error(message); };
var logFunction = function (message) { console.log(message); }; // tslint:disable-line:no-console
describe('evaluateEnabled should correctly validate if the plugin is enabled', function () {
    test('It should throw if no ssmPublish settings are passed', function () {
        var testEvaluate = function () { return (0, util_1.evaluateEnabled)({}, throwFunction); }; // tslint:disable-line:no-object-literal-type-assertion
        expect(testEvaluate).toThrow();
    });
    test('It should throw if enabled is a string and not true or false', function () {
        var testEvaluate = function () { return (0, util_1.evaluateEnabled)({ ssmPublish: { enabled: 'bla' } }, throwFunction); }; // tslint:disable-line:no-object-literal-type-assertion
        expect(testEvaluate).toThrow(); // tslint:disable-line:no-object-literal-type-assertion
    });
    test('It should return false if enabled is set to false', function () {
        expect((0, util_1.evaluateEnabled)({ ssmPublish: { enabled: false } }, throwFunction)).toEqual(false); // tslint:disable-line:no-object-literal-type-assertion
    });
    test('It should return true if enabled does not exist', function () {
        expect((0, util_1.evaluateEnabled)({ ssmPublish: {} }, throwFunction)).toEqual(true); // tslint:disable-line:no-object-literal-type-assertion
    });
    test('It should return true if enabled is true', function () {
        expect((0, util_1.evaluateEnabled)({ ssmPublish: { enabled: true } }, throwFunction)).toEqual(true); // tslint:disable-line:no-object-literal-type-assertion
    });
});
describe('validateParams should correctly validate user input', function () {
    test('It should throw if no params are present', function () {
        var mockData = undefined;
        var testValidate = function () { return (0, util_1.validateParams)(mockData, throwFunction, logFunction); }; // tslint:disable-line:no-object-literal-type-assertion
        expect(testValidate).toThrow('No params defined');
    });
    test('It should throw if required fields are missing', function () {
        var mockData = [{ path: 'bblablabla' }];
        var testValidate = function () { return (0, util_1.validateParams)(mockData, throwFunction, logFunction); }; // tslint:disable-line:no-object-literal-type-assertion
        expect(testValidate).toThrow('path and either value or source are required fields for params');
    });
    test('It should throw if the param path breaks AWS namespace rules (aws/ssm start)', function () {
        var mockData = [{ path: 'aws/test/', value: 'test' }];
        var testValidate = function () { return (0, util_1.validateParams)(mockData, throwFunction, logFunction); };
        expect(testValidate).toThrow("Param aws/test/ name doesn't match AWS constraints");
    });
    test('It should throw if the param path breaks AWS namespace rules (illegal characters)', function () {
        var mockData = [{ path: '/test/*__+23s', value: 'test' }];
        var testValidate = function () { return (0, util_1.validateParams)(mockData, throwFunction, logFunction); };
        expect(testValidate).toThrow("Param /test/*__+23s name doesn't match AWS constraints");
    });
    test('It should throw if the param path breaks AWS namespace rules (max nesting depth)', function () {
        var mockData = [{ path: '/a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/', value: 'test' }];
        var testValidate = function () { return (0, util_1.validateParams)(mockData, throwFunction, logFunction); };
        expect(testValidate).toThrow("Param /a/b/c/d/e/f/g/h/i/j/k/l/m/n/o/p/q/ name doesn't match AWS constraints");
    });
    test('It should throw if the param path breaks AWS namespace rules (max maxLength)', function () {
        var maxNameLength = 1011;
        var mockData = [{ path: 'a'.repeat(maxNameLength + 1), value: 'test' }];
        var testValidate = function () { return (0, util_1.validateParams)(mockData, throwFunction, logFunction); };
        expect(testValidate).toThrow("Param ".concat('a'.repeat(maxNameLength + 1), " name doesn't match AWS constraints"));
    });
    test('It should throw if the param description breaks AWS validation rules (max maxLength)', function () {
        var maxNameLength = 1024;
        var mockData = [{ path: 'test', value: 'test', description: 'a'.repeat(maxNameLength + 1) }];
        var testValidate = function () { return (0, util_1.validateParams)(mockData, throwFunction, logFunction); };
        expect(testValidate).toThrow("Param test description is too long");
    });
    test('It should return valid input as expected (default secure to true)', function () {
        var mockData = [
            { path: '/test/param', value: 'test' },
            { path: '/test/param1', value: 'test', secure: false, description: 'valid' },
            { path: 'test/param2', value: 'test', secure: true, description: 'valid' },
            { path: 'test/param3', value: 'test,test2', secure: true, type: 'StringList', description: 'valid' },
        ];
        var expectedResult = [
            { path: '/test/param', value: 'test', secure: true },
            { path: '/test/param1', value: 'test', secure: false, description: 'valid' },
            { path: 'test/param2', value: 'test', secure: true, description: 'valid' },
            { path: 'test/param3', value: 'test,test2', secure: true, type: 'StringList', description: 'valid' },
        ];
        expect((0, util_1.validateParams)(mockData, throwFunction, logFunction)).toStrictEqual(expectedResult);
    });
});
describe('compareParams should correctly compare and sort local and remote params', function () {
    test('It should show all local params as nonExisting if no remote params were found', function () {
        var localMockData1 = [
            { path: '/test/ssmParams/testToken2', value: 'update', description: 'test description', secure: true },
            { path: '/test/ssmParams/testToken3', value: ['update1', 'update2'], type: 'StringList', description: 'test description' },
        ];
        expect((0, util_1.compareParams)(localMockData1, []).nonExistingParams).toStrictEqual(localMockData1);
    });
    test('It should correctly assign all 3 possibilities', function () {
        var localMockData = [
            { path: '/test/ssmParams/unchangedToken', value: 'update', description: 'test description', secure: true },
            { path: '/test/ssmParams/changedToken', value: 'testtesttest', secure: true },
            { path: '/test/ssmParams/nonExistingToken', value: 'newToken', secure: true },
            { path: '/test/ssmParams/testToken3', value: ['update1', 'update2'], type: 'StringList', description: 'test description' },
        ];
        var remoteMockData = [
            {
                Name: '/test/ssmParams/changedToken',
                Type: 'String',
                Value: 'changed',
            },
            {
                Name: '/test/ssmParams/testToken3',
                Type: 'StringList',
                Value: 'update',
            },
            {
                Name: '/test/ssmParams/unchangedToken',
                Type: 'SecureString',
                Value: 'update',
            },
        ];
        expect((0, util_1.compareParams)(localMockData, remoteMockData).existingUnchangedParams).toStrictEqual([localMockData[0]]);
        expect((0, util_1.compareParams)(localMockData, remoteMockData).existingChangedParams).toStrictEqual([localMockData[1], localMockData[3]]); // tslint:disable-line:no-magic-numbers
        expect((0, util_1.compareParams)(localMockData, remoteMockData).nonExistingParams).toStrictEqual([localMockData[2]]); // tslint:disable-line:no-magic-numbers
    });
});
//# sourceMappingURL=util.test.js.map