/**
* @file integrationTests.js
* @module integrationTests
* @description Contains all of the commands to test various components of the system.
* @requires module:commandBroker
* @requires module:ruleBroker
* @requires module:workflowBroker
* @requires module:colorizer
* @requires module:configurator
* @requires module:loggers
* @requires module:data
* @requires module:queue
* @requires module:stack
* @requires {@link https://www.npmjs.com/package/@haystacks/constants|@haystacks/constants}
* @requires {@link https://www.npmjs.com/package/path|path}
* @author Seth Hollingsead
* @date 2022/03/25
* @copyright Copyright © 2022-… by Seth Hollingsead. All rights reserved
*/
// Internal imports
import commandBroker from '../../brokers/commandBroker.js';
import ruleBroker from '../../brokers/ruleBroker.js';
import workflowBroker from '../../brokers/workflowBroker.js';
import colorizer from '../../executrix/colorizer.js';
import configurator from '../../executrix/configurator.js';
import loggers from '../../executrix/loggers.js';
import D from '../../structures/data.js';
import queue from '../../structures/queue.js';
import stack from '../../structures/stack.js';
// External imports
import hayConst from '@haystacks/constants';
import path from 'path';
const {bas, biz, clr, cmd, cfg, msg, sys, wrd} = hayConst;
const baseFileName = path.basename(import.meta.url, path.extname(import.meta.url));
// framework.commandsBlob.commands.integrationTests.
const namespacePrefix = wrd.cframework + bas.cDot + sys.ccommandsBlob + bas.cDot + wrd.ccommands + bas.cDot + baseFileName + bas.cDot;
/**
* @function validateConstants
* @description Validates all constants with a 2-phase verification process.
* @param {array<string>} inputData An array that could possibly include the name of this command,
* and a list of top-level constants validation data structures to be validated.
* That way we can parameterize and optimize the validation of the constants specific to the testing needs.
* Rather than always running the full set of constants validation, as that could take a very long time,
* and only needs to be done exhaustively when releasing a new instance of the entire Haystacks platform.
* inputData[1] = validateConstants - This command name
* inputData[2] = Could be a coma-separated string list of constants validation data to validate.
* inputData[n] = Could be additional list of constants validation data to validate if the user entered a space-separated list.
* Options are: Framework,Platform,Application,App,Plugins,Plugin
* @param {string} inputMetaData Not used for this command.
* @return {array<boolean,string|integer|boolean|object|array>} An array with a boolean True or False value to
* indicate if the application should exit or not exit, followed by the command output.
* @author Seth Hollingsead
* @date 2022/03/25
*/
async function validateConstants(inputData, inputMetaData) {
let functionName = validateConstants.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
let returnData = [true, false];
if (await configurator.getConfigurationSetting(wrd.csystem, cfg.cenableConstantsValidation) === true) {
let pluginNamespace = '';
let processingPluginResults = false;
let validationTypesInputArray = []; // Use this to process any inputs the user may have entered.
let validationTypesConfirmedArray = []; // Use this once we've confirmed valid user entry for inputs given the types of validation that are available.
let validationTypesConfirmedList = '';
let validUserEntry = false;
// Get the array of keys and values for all the constants that need to be validated.
let validationArray = []; // D[sys.cConstantsValidationData][sys.cConstantsFilePaths]; // This will return an object with all of the key-value pair attributes we need.
let validationFrameworkArray = D[sys.cConstantsValidationData][wrd.cFramework][sys.cConstantsFilePaths]; // Framework constants paths
let validationApplicationArray = D[sys.cConstantsValidationData][wrd.cApplication][sys.cConstantsFilePaths]; // Application constants paths
let validationPluginsMetaArray = D[sys.cConstantsValidationData][wrd.cPlugins]; // Will need to iterate through each of the plugins and capture the plugin constants path for each plugin!
let phase1FinalResult = true;
let phase2FinalResult = true;
let phase1Results = {};
let phase2Results = {};
let validConstantsValidationTypes = [wrd.cFramework, wrd.cApplication, wrd.cPlugins];
let validConstantsValidationUserTypes = [wrd.cFramework, wrd.cPlatform, wrd.cApplication, wrd.cApp, wrd.cPlugins, wrd.cPlugin]
// validationFrameworkArray is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationFrameworkArrayIs + JSON.stringify(validationFrameworkArray));
// validationApplicationArray is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationApplicationArrayIs + JSON.stringify(validationApplicationArray));
// validationPluginsMetaArray is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationPluginsMetaArrayIs + JSON.stringify(validationPluginsMetaArray));
// Check first to see what, if any options, the user may have entered into this command,
// that will determine to what extent we do validation.
if (Array.isArray(inputData) && inputData.length === 2) {
// User either entered a single data structure to validate, or a coma-separated list.
// inputData.length is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataLengthIs + inputData.length);
if (inputData[1].includes(bas.cComa)) {
validationTypesInputArray = inputData[1].split(bas.cComa);
} else if (inputData[1].includes(bas.cSemiColon)) {
validationTypesInputArray = inputData[1].split(bas.cSemiColon);
} else if (inputData[1].includes(bas.cForwardSlash)) {
validationTypesInputArray = inputData[1].split(bas.cForwardSlash);
} else if (inputData[1].includes(bas.cBackSlash)) {
validationTypesInputArray = inputData[1].split(bas.cBackSlash);
} else {
// shift the data1!
await loggers.consoleLog(namespacePrefix + functionName, msg.cshiftData1);
inputData.shift();
validationTypesInputArray = inputData;
}
} else if (Array.isArray(inputData) && inputData.length > 2) {
// shift the data2!
await loggers.consoleLog(namespacePrefix + functionName, msg.cshiftData2);
inputData.shift();
validationTypesInputArray = inputData;
}
// validationTypesInputArray is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationTypesInputArrayIs + JSON.stringify(validationTypesInputArray));
// This is where we need to process the array of inputs to normalize them to the validation types available by the system.
// Available types are: Framework,Platform,Application,App,Plugins,Plugin
if (validationTypesInputArray.length > 0) {
for (let validationTypesKey in validationTypesInputArray) {
let userEnteredValidationType = validationTypesInputArray[validationTypesKey];
if (userEnteredValidationType.toUpperCase().trim() === wrd.cFRAMEWORK || userEnteredValidationType.toUpperCase().trim() === wrd.cPLATFORM) {
validationTypesConfirmedArray.push(wrd.cFramework);
} else if (userEnteredValidationType.toUpperCase().trim() === wrd.cAPPLICATION || userEnteredValidationType.toUpperCase().trim() === wrd.cAPP) {
validationTypesConfirmedArray.push(wrd.cApplication);
} else if (userEnteredValidationType.toUpperCase().trim() === wrd.cPLUGINS || userEnteredValidationType.toUpperCase().trim() === wrd.cPLUGIN) {
validationTypesConfirmedArray.push(wrd.cPlugins);
} else if (userEnteredValidationType === '') {
// Just ignore it!
} else {
// WARNING: The specified validation type is not available, please enter a valid type and try again. Type not recognized:
// Constants validation types are:
console.log(msg.cWarningUserEnteredConstantsValidationDataTypeMessage01 + userEnteredValidationType);
console.log(msg.cWarningUserEnteredConstantsValidationDataTypeMessage02 + validConstantsValidationUserTypes.join(bas.cComa + bas.cSpace));
}
} // End-for (let validationTypesKey in validationTypesInputArray)
// validationTypesConfirmedArray is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationTypesConfirmedArrayIs + JSON.stringify(validationTypesConfirmedArray));
if (validationTypesConfirmedArray.length > 0) {
validationTypesConfirmedList = validationTypesConfirmedArray.join(bas.cComa);
validUserEntry = true;
} else {
// WARNING: No valid constants validation types were entered.
console.log(msg.cWarningUserEnteredConstantsValidationDataTypeMessage03);
// Constants validation types are:
console.log(msg.cWarningUserEnteredConstantsValidationDataTypeMessage02 + validConstantsValidationUserTypes.join(bas.cComa + bas.cSpace));
}
} else {
// User didn't enter any parameters at all....just run it all!
validationTypesConfirmedList = validConstantsValidationTypes.join(bas.cComa);
validUserEntry = true;
}
// validationTypesConfirmedList is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationTypesConfirmedListIs + validationTypesConfirmedList);
if (validUserEntry) {
if (validationTypesConfirmedList.includes(wrd.cFramework)) {
validationArray = validationFrameworkArray;
}
if (validationTypesConfirmedList.includes(wrd.cApplication)) {
validationArray = Object.assign(validationArray, validationApplicationArray);
}
// validationArray before plugin constants validation data merge is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationArrayBeforePluginConstantsValidationDataMergeIs + JSON.stringify(validationArray));
if (await configurator.getConfigurationSetting(wrd.csystem, cfg.cenablePluginLoader)) {
if (validationTypesConfirmedList.includes(wrd.cPlugins)) {
for (let plugin in validationPluginsMetaArray) {
// plugin is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cpluginIs + plugin);
let pluginValidationPathData = validationPluginsMetaArray[plugin][sys.cConstantsFilePaths];
for (let constantsFilePathName in pluginValidationPathData) {
// constantsFilePathName is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cconstantsFilePathNamesIs + constantsFilePathName);
let constantsFilePathValue = pluginValidationPathData[constantsFilePathName];
// constantsFilePathValue is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cconstantsFilePathValueIs + constantsFilePathValue);
let newPluginConstantValidationName = plugin + bas.cColon + constantsFilePathName;
// newPluginConstantValidationName is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cnewPluginConstantValidationNameIs + newPluginConstantValidationName);
let newPluginConstantValidationPathObject = {[newPluginConstantValidationName]: constantsFilePathValue};
validationArray = Object.assign(validationArray, newPluginConstantValidationPathObject);
// validationArray after plugin constants validation data merge is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationArrayAfterPluginConstantsValidationDataMergeIs + JSON.stringify(validationArray));
} // End-for (let constantsFilePathNames in pluginValidationPathData)
} // End-for (let plugin in validationPluginsMetaArray)
} // End-if (validationTypesConfirmedList.includes(wrd.cPlugins))
} // End-if (await configurator.getConfigurationSetting(wrd.csystem, cfg.cenablePluginLoader))
// validationArray is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationArrayIs + JSON.stringify(validationArray));
// Phase1 Constants Validation
// BEGIN Phase 1 Constants Validation
await loggers.consoleLog(namespacePrefix + functionName, msg.cBeginPhase1ConstantsValidation);
console.log(msg.cBeginPhase1ConstantsValidation);
// First scan through each file and validate that the constants defined in the constants code file are also contained in the validation file.
for (let key1 in validationArray) {
let constantsPath = validationArray[key1];
phase1Results[key1] = await ruleBroker.processRules([constantsPath, key1], [biz.cvalidateConstantsDataValidation]);
} // End-for (let key1 in validationArray)
// END Phase 1 Constants Validation
await loggers.consoleLog(namespacePrefix + functionName, msg.cEndPhase1ConstantsValidation);
// phase1Results is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cphase1ResultsIs + JSON.stringify(phase1Results));
// Phase 2 Constants Validation
// BEGIN Phase 2 Constants Validation
await loggers.consoleLog(namespacePrefix + functionName, msg.cBeginPhase2ConstantsValidation);
console.log(msg.cBeginPhase2ConstantsValidation);
// Now verify that the values of the constants are what they are expected to be by using the constants validation data to validate.
for (let key2 in validationArray) {
phase2Results[key2] = await ruleBroker.processRules([key2, ''], [biz.cvalidateConstantsDataValues]);
} // End-for (let key2 in validationArray)
// END Phase 2 Constants Validation
await loggers.consoleLog(namespacePrefix + functionName, msg.cEndPhase2ConstantsValidation);
// phase2Results is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cphase2ResultsIs + JSON.stringify(phase2Results));
for (let key3 in phase1Results) {
let constantsPhase1ValidationNamespaceParentObject = await ruleBroker.processRules([key3, ''], [biz.cgetConstantsValidationNamespaceParentObject]);
if (key3.includes(bas.cColon) && key3.toUpperCase().includes(wrd.cPLUGIN)) {
let pluginPhase1NamespaceArray = key3.split(bas.cColon);
pluginNamespace = pluginPhase1NamespaceArray[1];
processingPluginResults = true;
}
if (processingPluginResults === false) {
await loggers.constantsValidationSummaryLog(constantsPhase1ValidationNamespaceParentObject[sys.cConstantsPhase1ValidationMessages][key3], phase1Results[key3]);
} else if (processingPluginResults === true) {
await loggers.constantsValidationSummaryLog(constantsPhase1ValidationNamespaceParentObject[sys.cConstantsPhase1ValidationMessages][pluginNamespace], phase1Results[key3]);
}
processingPluginResults = false;
pluginNamespace = '';
if (phase1Results[key3] === false) {
phase1FinalResult = false;
}
} // End-for (let key3 in phase1ResultsArray)
for (let key4 in phase2Results) {
let constantsPhase2ValidationNamespaceParentObject = await ruleBroker.processRules([key4, ''], [biz.cgetConstantsValidationNamespaceParentObject]);
if (key4.includes(bas.cColon) && key4.toUpperCase().includes(wrd.cPLUGIN)) {
let pluginPhase2NamespaceArray = key4.split(bas.cColon);
pluginNamespace = pluginPhase2NamespaceArray[1];
processingPluginResults = true;
}
if (processingPluginResults === false) {
await loggers.constantsValidationSummaryLog(constantsPhase2ValidationNamespaceParentObject[sys.cConstantsPhase2ValidationMessages][key4], phase2Results[key4]);
} else if (processingPluginResults === true) {
await loggers.constantsValidationSummaryLog(constantsPhase2ValidationNamespaceParentObject[sys.cConstantsPhase2ValidationMessages][pluginNamespace], phase2Results[key4]);
}
processingPluginResults = false
pluginNamespace = '';
if (phase2Results[key4] === false) {
phase2FinalResult = false;
}
} // End-for (let key4 in phase2Results)
if (phase1FinalResult === true && phase2FinalResult === true) {
await configurator.setConfigurationSetting(wrd.csystem, cfg.cpassAllConstantsValidation, true);
returnData[1] = true;
} else {
await configurator.setConfigurationSetting(wrd.csystem, cfg.cpassAllConstantsValidation, false);
returnData[1] = false;
}
} else {
await configurator.setConfigurationSetting(wrd.csystem, cfg.cpassAllConstantsValidation, false);
returnData[1] = false;
} // End-if (validUserEntry)
} else {
// The enableConstantsValidation flag is disabled. Enable this flag in the configuration settings to activate this command.
console.log(msg.ccconstantsGeneratorMessage3 + msg.cconstantsGeneratorMessage4);
await configurator.setConfigurationSetting(wrd.csystem, cfg.cpassAllConstantsValidation, false);
returnData[1] = false;
}
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function validateCommandAliases
* @description Validates all command aliases have no duplicates within a command, but also between commands.
* @param {array<string>} inputData An array that could possibly include the name of this command,
* and a list of top-level command aliases data structures to be validated.
* That way we can parameterize and optimize the validation of the command aliases specific to the testing needs.
* Rather than always running the full set of command aliases, as that could take a very long time,
* and only needs to be done exhaustively when releasing a new instance of the entire Haystacks platform.
* inputData[1] = validateCommandAliases
* inputData[2] = Could be a coma-separated string list of command alias data types to validate.
* inputData[n] = Could be additional list of command alias list data to validate if the user entered a space-separated list.
* Options are: Framework,Platform,Application,App,Plugins,Plugin
* @param {string} inputMetaData Not used for this command.
* @return {array<boolean,string|integer|boolean|object|array>} An array with a boolean True or False value to
* indicate if the application should exit or not exit, followed by the command output.
* @author Seth Hollingsead
* @date 2022/03/30
*/
async function validateCommandAliases(inputData, inputMetaData) {
let functionName = validateCommandAliases.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
let returnData = [true, false];
let validationTypesInputArray = []; // Use this to process any inputs the user may have entered.
let validationTypesConfirmedArray = []; // Use this once we've confirmed valid user entry for inputs given the types of validation that are available.
let validationTypesConfirmedList = '';
let validUserEntry = false;
let allCommandAliasesToValidate = []
let passedAllCommandAliasesDuplicateCheck = true;
let duplicateAliasCount = 0
let blackColorArray = await colorizer.getNamedColorData(clr.cBlack, [0,0,0]);
let redColorArray = await colorizer.getNamedColorData(clr.cRed, [255,0,0]);
let validCommandAliasesValidationTypes = [wrd.cFramework, wrd.cApplication, wrd.cPlugins];
let validCommandAliasesValidationUserTypes = [wrd.cFramework, wrd.cPlatform, wrd.cApplication, wrd.cApp, wrd.cPlugins, wrd.cPlugin];
// Process user input(s).
// Check first to see what, if any options, the user may have entered into this command,
// that will determine to what extent we do validation.
if (Array.isArray(inputData) && inputData.length === 2) {
// User either entered a single data structure to validate, or a coma-separated list.
// inputData.length is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataLengthIs + inputData.length);
if (inputData[1].includes(bas.cComa)) {
validationTypesInputArray = inputData[1].split(bas.cComa);
} else if (inputData[1].includes(bas.cSemiColon)) {
validationTypesInputArray = inputData[1].split(bas.cSemiColon);
} else if (inputData[1].includes(bas.cForwardSlash)) {
validationTypesInputArray = inputData[1].split(bas.cForwardSlash);
} else if (inputData[1].includes(bas.cBackSlash)) {
validationTypesInputArray = inputData[1].split(bas.cBackSlash);
} else {
// shift the data1!
await loggers.consoleLog(namespacePrefix + functionName, msg.cshiftData1);
inputData.shift();
validationTypesInputArray = inputData;
}
} else if (Array.isArray(inputData) && inputData.length > 2) {
// shift the data2!
await loggers.consoleLog(namespacePrefix + functionName, msg.cshiftData2);
inputData.shift();
validationTypesInputArray = inputData;
}
// validationTypesInputArray is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationTypesInputArrayIs + JSON.stringify(validationTypesInputArray));
// This is where we need to process the array of inputs to normalize them to the validation types available by the system.
// Available types are: Framework,Platform,Application,App,Plugins,Plugin
if (validationTypesInputArray.length > 0) {
for (let validationTypesKey in validationTypesInputArray) {
let userEnteredValidationType = validationTypesInputArray[validationTypesKey];
if (userEnteredValidationType.toUpperCase().trim() === wrd.cFRAMEWORK || userEnteredValidationType.toUpperCase().trim() === wrd.cPLATFORM) {
validationTypesConfirmedArray.push(wrd.cFramework);
} else if (userEnteredValidationType.toUpperCase().trim() === wrd.cAPPLICATION || userEnteredValidationType.toUpperCase().trim() === wrd.cAPP) {
validationTypesConfirmedArray.push(wrd.cApplication);
} else if (userEnteredValidationType.toUpperCase().trim() === wrd.cPLUGINS || userEnteredValidationType.toUpperCase().trim() === wrd.cPLUGIN) {
validationTypesConfirmedArray.push(wrd.cPlugins);
} else if (userEnteredValidationType === '') {
// Just ignore it!
} else {
// WARNING: The specified validation type is not available, please enter a valid type and try again. Type not recognized:
console.log(msg.cWarningUserEnteredConstantsValidationDataTypeMessage01 + userEnteredValidationType);
// Command Aliases validation types are:
console.log(msg.cWarningUserEnteredCommandAliasesValidationDataTypeMessage02 + validCommandAliasesValidationUserTypes.join(bas.cComa + bas.cSpace));
}
} // End-for (let validationTypesKey in validationTypesInputArray)
// validationTypesConfirmedArray is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationTypesConfirmedArrayIs + JSON.stringify(validationTypesConfirmedArray));
if (validationTypesConfirmedArray.length > 0) {
validationTypesConfirmedList = validationTypesConfirmedArray.join(bas.cComa);
validUserEntry = true;
} else {
// WARNING: No valid command aliases validation types were entered.
console.log(msg.cWarningUserEnteredCommandAliasesValidationDataTypeMessage03);
// Command Aliases validation types are:
console.log(msg.cWarningUserEnteredCommandAliasesValidationDataTypeMessage02 + validCommandAliasesValidationUserTypes.join(bas.cComa + bas.cSpace));
}
} else {
// User didn't enter any parameters at all....just run it all!
validationTypesConfirmedList = validCommandAliasesValidationTypes.join(bas.cComa);
validUserEntry = true;
}
// validationTypesConfirmedList is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationTypesConfirmedListIs + validationTypesConfirmedList);
if (validUserEntry === true) {
if (validationTypesConfirmedList.includes(wrd.cFramework)) {
let frameworkCommandAliases = await commandBroker.getAllCommandAliasData(D[sys.cCommandsAliases][wrd.cFramework]);
// frameworkCommandAliases is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cframeworkCommandAliasesIs + JSON.stringify(frameworkCommandAliases));
if (frameworkCommandAliases) {
allCommandAliasesToValidate = await ruleBroker.processRules([allCommandAliasesToValidate, frameworkCommandAliases], [biz.cobjectDeepMerge]);
}
}
if (validationTypesConfirmedList.includes(wrd.cApplication)) {
let applicationCommandAliases = await commandBroker.getAllCommandAliasData(D[sys.cCommandsAliases][wrd.cApplication]);
// applicationCommandAliases is:
await loggers.consoleLog(namespacePrefix + functionName, msg.capplicationCommandAliasesIs + JSON.stringify(applicationCommandAliases));
if (applicationCommandAliases) {
if (Object.keys(allCommandAliasesToValidate).length != 0) {
allCommandAliasesToValidate = await ruleBroker.processRules([allCommandAliasesToValidate, applicationCommandAliases], [biz.cobjectDeepMerge]);
} else {
allCommandAliasesToValidate = applicationCommandAliases;
}
}
}
if (await configurator.getConfigurationSetting(wrd.csystem, cfg.cenablePluginLoader)) {
if (validationTypesConfirmedList.includes(wrd.cPlugins)) {
let pluginCommandAliases = await commandBroker.getAllCommandAliasData(D[sys.cCommandsAliases][wrd.cPlugins]);
// pluginCommandAliases is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cpluginCommandAliasesIs + JSON.stringify(pluginCommandAliases));
if (pluginCommandAliases) {
if (Object.keys(allCommandAliasesToValidate).length != 0) {
allCommandAliasesToValidate = await ruleBroker.processRules([allCommandAliasesToValidate, pluginCommandAliases], [biz.cobjectDeepMerge]);
} else {
allCommandAliasesToValidate = pluginCommandAliases;
}
}
}
}
// Old method of getting all the command aliases data:
// allCommandAliasesToValidate = await commandBroker.getAllCommandAliasData(D[sys.cCommandsAliases]);
// allCommandAliasesToValidate is:
await loggers.consoleLog(namespacePrefix + functionName, msg.callCommandAliasesToValidateIs + JSON.stringify(allCommandAliasesToValidate));
// Now do the validation from the flattened array of command aliases data.
// Begin command aliases validation
console.log(msg.cBeginCommandAliasesValidationMessage);
for (let key1 in allCommandAliasesToValidate[0]) {
// key1 is:
await loggers.consoleLog(namespacePrefix + functionName, msg.ckey1Is + key1);
let currentCommand = allCommandAliasesToValidate[0][key1];
// currentCommand is:
await loggers.consoleLog(namespacePrefix + functionName, msg.ccurrentCommandIs + JSON.stringify(currentCommand));
console.log(msg.ccurrentCommandIs + currentCommand[wrd.cName]);
let aliasList = currentCommand[wrd.cAliases];
// aliasList is:
await loggers.consoleLog(namespacePrefix + functionName, msg.caliasListIs + aliasList);
let arrayOfAliases = aliasList.split(bas.cComa);
for (let j = 0; j < arrayOfAliases.length; j++) {
// BEGIN j-th loop:
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_jthLoop + j);
let currentAlias = arrayOfAliases[j];
// currentAlias is:
await loggers.consoleLog(namespacePrefix + functionName, msg.ccurrentAliasIs + currentAlias);
duplicateAliasCount = await commandBroker.countMatchingCommandAlias(D[sys.cCommandsAliases], currentAlias);
if (duplicateAliasCount > 1) {
// duplicateAliasCount is:
let duplicateAliasCountMessage = msg.cduplicateAliasCountIs + duplicateAliasCount;
duplicateAliasCountMessage = await colorizer.colorizeMessageSimple(duplicateAliasCountMessage, blackColorArray, true);
duplicateAliasCountMessage = await colorizer.colorizeMessageSimple(duplicateAliasCountMessage, redColorArray, false);
console.log(duplicateAliasCountMessage);
// duplicate command alias is:
let duplicateAliasCommandMessage = msg.cduplicateCommandAliasIs + currentAlias;
duplicateAliasCommandMessage = await colorizer.colorizeMessageSimple(duplicateAliasCommandMessage, blackColorArray, true);
duplicateAliasCommandMessage = await colorizer.colorizeMessageSimple(duplicateAliasCommandMessage, redColorArray, false);
console.log(duplicateAliasCommandMessage);
passedAllCommandAliasesDuplicateCheck = false;
returnData[1] = false;
// DO NOT break out of any loops here, the command should scan all command aliases!
}
// END j-th loop:
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_jthLoop + j);
} // End-for (let j = 0; j < arrayOfAliases.length; j++)
} // End-for (let key1 in allCommandAliasesToValidate[0])
if (passedAllCommandAliasesDuplicateCheck === true) {
// PASSED: All duplicate command aliases validation tests!
console.log(msg.cvalidateCommandAliasesMessage1);
returnData[1] = true;
} // End-if (passedAllCommandAliasesDuplicateCheck === true)
} else {
// No validation was run, YOU SHALL NOT PASS!!!!
passedAllCommandAliasesDuplicateCheck = false;
returnData[1] = false;
} // End-if (validUserEntry === true)
await configurator.setConfigurationSetting(wrd.csystem, cfg.cpassedAllCommandAliasesDuplicateChecks, passedAllCommandAliasesDuplicateCheck);
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function validateWorkflows
* @description Validates all the workflows have no duplicates.
* @param {array<string>} inputData An array that could possibly include the name of this command,
* and a ist of top-level workflows data structures to be validated.
* That way we can parameterize and optimize the validation of the workflows specific to the testing needs.
* Rather than always running the full set of workflows, as that could take longer,
* and only needs to be done exhaustively when releasing a new instance of the entire Haystacks platform.
* inputData[1] = validateWorkflows
* inputData[2] = Could be a coma-separated string list of workflow data types to validate.
* inputData[n] = Could be additional list of workflow data types list to validate if the user entered a space-separated list.
* Options are: Framework,Platform,Application,App,Plugins,Plugin
* @param {string} inputMetaData Not used for this command.
* @return {array<boolean,string|integer|boolean|object|array>} An array with a boolean True or False value to
* indicate if the application should exit or not exit, followed by the command output.
* @author Seth Hollingsead
* @date 2022/06/08
*/
async function validateWorkflows(inputData, inputMetaData) {
let functionName = validateWorkflows.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
let returnData = [true, false];
let validationTypesInputArray = []; // Use this to process any inputs the user may have entered.
let validationTypesConfirmedArray = []; // Use this once we've confirmed valid user entry for inputs given the types of validation that are available.
let validationTypesConfirmedList = '';
let validUserEntry = false;
let allWorkflowsToValidate = [];
let numberOfDuplicatesFound = 0;
let passedAllWorkflowDuplicateCheck = true;
let blackColorArray = await colorizer.getNamedColorData(clr.cBlack, [0,0,0]);
let redColorArray = await colorizer.getNamedColorData(clr.cRed, [255,0,0]);
let validWorkflowsValidationTypes = [wrd.cFramework, wrd.cApplication, wrd.cPlugins];
let validWorkflowsValidationUserTypes = [wrd.cFramework, wrd.cPlatform, wrd.cApplication, wrd.cApp, wrd.cPlugins, wrd.cPlugin];
// Process user input(s).
// Check first to see what, if any options, the user may have entered into this command,
// that will determine to what extent we do validation.
if (Array.isArray(inputData) && inputData.length === 2) {
// User either entered a single data structure to validate, or a coma-separated list.
// inputData.length is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataLengthIs + inputData.length);
if (inputData[1].includes(bas.cComa)) {
validationTypesInputArray = inputData[1].split(bas.cComa);
} else if (inputData[1].includes(bas.cSemiColon)) {
validationTypesInputArray = inputData[1].split(bas.cSemiColon);
} else if (inputData[1].includes(bas.cForwardSlash)) {
validationTypesInputArray = inputData[1].split(bas.cForwardSlash);
} else if (inputData[1].includes(bas.cBackSlash)) {
validationTypesInputArray = inputData[1].split(bas.cBackSlash);
} else {
// shift the data1!
await loggers.consoleLog(namespacePrefix + functionName, msg.cshiftData1);
inputData.shift();
validationTypesInputArray = inputData;
}
} else if (Array.isArray(inputData) && inputData.length > 2) {
// shift the data2!
await loggers.consoleLog(namespacePrefix + functionName, msg.cshiftData2);
inputData.shift();
validationTypesInputArray = inputData;
}
// validationTypesInputArray is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationTypesInputArrayIs + JSON.stringify(validationTypesInputArray));
// This is where we need to process the array of inputs to normalize them to the validation types available by the system.
// Available types are: Framework,Platform,Application,App,Plugins,Plugin
if (validationTypesInputArray.length > 0) {
for (let validationTypesKey in validationTypesInputArray) {
let userEnteredValidationType = validationTypesInputArray[validationTypesKey];
if (userEnteredValidationType.toUpperCase().trim() === wrd.cFRAMEWORK || userEnteredValidationType.toUpperCase().trim() === wrd.cPLATFORM) {
validationTypesConfirmedArray.push(wrd.cFramework);
} else if (userEnteredValidationType.toUpperCase().trim() === wrd.cAPPLICATION || userEnteredValidationType.toUpperCase().trim() === wrd.cAPP) {
validationTypesConfirmedArray.push(wrd.cApplication);
} else if (userEnteredValidationType.toUpperCase().trim() === wrd.cPLUGINS || userEnteredValidationType.toUpperCase().trim() === wrd.cPLUGIN) {
validationTypesConfirmedArray.push(wrd.cPlugins);
} else if (userEnteredValidationType === '') {
// Just ignore it!
} else {
// WARNING: The specified validation type is not available, please enter a valid type and try again. Type not recognized:
console.log(msg.cWarningUserEnteredConstantsValidationDataTypeMessage01 + userEnteredValidationType);
// Workflows validation types are:
console.log(msg.cWarningUserEnteredWorkflowsValidationDataTypeMessage02 + validWorkflowsValidationUserTypes.join(bas.cComa + bas.cSpace));
}
} // End-for (let validationTypesKey in validationTypesInputArray)
// validationTypesConfirmedArray is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationTypesConfirmedArrayIs + JSON.stringify(validationTypesConfirmedArray));
if (validationTypesConfirmedArray.length > 0) {
validationTypesConfirmedList = validationTypesConfirmedArray.join(bas.cComa);
validUserEntry = true;
} else {
// WARNING: No valid workflow validation types were entered.
console.log(msg.cWarningUserEnteredWorkflowsValidationDataTypeMessage03);
// Workflows validation types are:
console.log(msg.cWarningUserEnteredWorkflowsValidationDataTypeMessage02 + validWorkflowsValidationUserTypes.join(bas.cComa + bas.cSpace));
}
} else {
// User didn't enter any parameters at all....just run it all!
validationTypesConfirmedList = validWorkflowsValidationTypes.join(bas.cComa);
validUserEntry = true;
}
// validationTypesConfirmedList is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationTypesConfirmedListIs + validationTypesConfirmedList);
if (validUserEntry === true) {
if (validationTypesConfirmedList.includes(wrd.cFramework)) {
allWorkflowsToValidate = await workflowBroker.getAllWorkflows(D[sys.cCommandWorkflows][wrd.cFramework]);
}
if (validationTypesConfirmedList.includes(wrd.cApplication)) {
allWorkflowsToValidate.push(...await workflowBroker.getAllWorkflows(D[sys.cCommandWorkflows][wrd.cApplication]));
}
if (await configurator.getConfigurationSetting(wrd.csystem, cfg.cenablePluginLoader)) {
if (validationTypesConfirmedList.includes(wrd.cPlugins)) {
allWorkflowsToValidate.push(...await workflowBroker.getAllWorkflows(D[sys.cCommandWorkflows][wrd.cPlugins]));
}
}
// Old method of getting all the command aliases data:
// allWorkflowsToValidate = await workflowBroker.getAllWorkflows(D[sys.cCommandWorkflows]);
// allWorkflowsToValidate is:
await loggers.consoleLog(namespacePrefix + functionName, msg.callWorkflowsToValidate + JSON.stringify(allWorkflowsToValidate));
// Begin workflows validation
console.log(msg.cBeginWorkflowsValidationMessage);
for (let workflowKey in allWorkflowsToValidate) {
numberOfDuplicatesFound = 0;
let workflowName = allWorkflowsToValidate[workflowKey];
// workflowName is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cworkflowNameIs + workflowName);
console.log(msg.cworkflowNameIs + workflowName);
for (const element of allWorkflowsToValidate) {
let secondTierWorkflowName = element;
// secondTierWorkflowName is:
await loggers.consoleLog(namespacePrefix + functionName, msg.csecondTierWorkflowNameIs + secondTierWorkflowName);
if (workflowName === secondTierWorkflowName) {
numberOfDuplicatesFound = numberOfDuplicatesFound + 1;
}
} // End-for (const element of allWorkflowsToValidate)
if (numberOfDuplicatesFound > 1) {
// Duplicate workflow count is:
let duplicateWorkflowCountMessage = msg.cDuplicateWorkflowCountIs + numberOfDuplicatesFound;
duplicateWorkflowCountMessage = await colorizer.colorizeMessageSimple(duplicateWorkflowCountMessage, blackColorArray, true);
duplicateWorkflowCountMessage = await colorizer.colorizeMessageSimple(duplicateWorkflowCountMessage, redColorArray, false);
console.log(duplicateWorkflowCountMessage);
// Duplicate workflow name is:
let duplicateWorkflowMessage = msg.cDuplicateWorkflowNameIs + workflowName;
duplicateWorkflowMessage = await colorizer.colorizeMessageSimple(duplicateWorkflowMessage, blackColorArray, true);
duplicateWorkflowMessage = await colorizer.colorizeMessageSimple(duplicateWorkflowMessage, redColorArray, false);
console.log(duplicateWorkflowMessage);
passedAllWorkflowDuplicateCheck = false;
returnData[1] = false;
} // End-if (numberOfDuplicatesFound > 1)
} // End-for (let workflowName in allWorkflowsToValidate)
} else {
// No validation was run, YOU SHALL NOT PASS!!!!
passedAllWorkflowDuplicateCheck = false;
returnData[1] = false;
} // End-if (validUserEntry === true)
if (passedAllWorkflowDuplicateCheck === true) {
// PASSED: All duplicate workflow validation tests!
console.log(msg.cvalidateWorkflowsMessage01);
returnData[1] = true;
} // End-if (passedAllWorkflowDuplicateCheck === true)
await configurator.setConfigurationSetting(wrd.csystem, cfg.cpassedAllWorkflowDuplicateChecks, passedAllWorkflowDuplicateCheck);
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
/**
* @function runAllValidations
* @description Runs all validations together, constants validation, command alias validation and workflow validation.
* @param {string} inputData An array that could possibly include the name of this command,
* and a list of top-level data structures that all validations should be run against.
* Rather than always running the full set of validations against everything, as that could take longer,
* and only needs to be done exhaustively when releasing a new instance of the entire Haystacks platform.
* inputData[1] = runAllValidations
* inputData[2] = Could be a coma-separated string list of data types to run all validation with.
* inputData[n] = Could be additional list of workflow data types list to validate if the user entered a space-separated list.
* Options are: Framework,Platform,Application,App,Plugins,Plugin
* @param {string} inputMetaData Not used for this command.
* @return {array<boolean,string|integer|boolean|object|array>} An array with a boolean True or False value to
* indicate if the application should exit or not exit, followed by the command output.
* @author Seth Hollingsead
* @date 2023/02/20
*/
async function runAllValidations(inputData, inputMetaData) {
let functionName = runAllValidations.name;
await loggers.consoleLog(namespacePrefix + functionName, msg.cBEGIN_Function);
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataIs + JSON.stringify(inputData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputMetaDataIs + inputMetaData);
let returnData = [true, false];
let validationTypesInputArray = []; // Use this to process any inputs the user may have entered.
let validationTypesConfirmedArray = []; // Use this once we've confirmed valid user entry for inputs given the types of validation that are available.
let validationTypesConfirmedList = '';
let validUserEntry = false;
let validValidationTypes = [wrd.cFramework, wrd.cApplication, wrd.cPlugins];
let validValidationUserTypes = [wrd.cFramework, wrd.cPlatform, wrd.cApplication, wrd.cApp, wrd.cPlugins, wrd.cPlugin];
// Process user input(s).
// Check first to see what, if any options, the user may have entered nto this command,
// that will determine to what extent we do validation.
if (Array.isArray(inputData) && inputData.length === 2) {
// User either entered a single data structure to validate, or a coma-separated list.
// inputData.length is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cinputDataLengthIs + inputData.length);
if (inputData[1].includes(bas.cComa)) {
validationTypesInputArray = inputData[1].split(bas.cComa);
} else if (inputData[1].includes(bas.cSemiColon)) {
validationTypesInputArray = inputData[1].split(bas.cSemiColon);
} else if (inputData[1].includes(bas.cForwardSlash)) {
validationTypesInputArray = inputData[1].split(bas.cForwardSlash);
} else if (inputData[1].includes(bas.cBackSlash)) {
validationTypesInputArray = inputData[1].split(bas.cForwardSlash);
} else {
// shift the data1!
await loggers.consoleLog(namespacePrefix + functionName, msg.cshiftData1);
inputData.shift();
validationTypesInputArray = inputData;
}
} else if (Array.isArray(inputData) && inputData.length > 2) {
// shift the data2!
await loggers.consoleLog(namespacePrefix + functionName, msg.cshiftData2);
inputData.shift();
validationTypesInputArray = inputData;
}
// validationTypesInputArray is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationTypesInputArrayIs + JSON.stringify(validationTypesInputArray));
// This is where we need to process the array of inputs to normalize them to the validation types available by the system.
// Available types are: Framework,Platform,Application,App,Plugins,Plugin
if (validationTypesInputArray.length > 0) {
for (let validationTypesKey in validationTypesInputArray) {
let userEnteredValidationType = validationTypesInputArray[validationTypesKey];
if (userEnteredValidationType.toUpperCase().trim() === wrd.cFRAMEWORK || userEnteredValidationType.toUpperCase().trim() === wrd.cPLATFORM) {
validationTypesConfirmedArray.push(wrd.cFramework);
} else if (userEnteredValidationType.toUpperCase().trim() === wrd.cAPPLICATION || userEnteredValidationType.toUpperCase().trim() === wrd.cAPP) {
validationTypesConfirmedArray.push(wrd.cApplication);
} else if (userEnteredValidationType.toUpperCase().trim() === wrd.cPLUGINS || userEnteredValidationType.toUpperCase().trim() === wrd.cPLUGIN) {
validationTypesConfirmedArray.push(wrd.cPlugins);
} else if (userEnteredValidationType === '') {
// Just ignore it
} else {
// WARNING: The specified validation type is not available, please enter a valid type and try again. Type not recognized:
console.log(msg.cWarningUserEnteredConstantsValidationDataTypeMessage01 + userEnteredValidationType);
// Validation types are:
console.log(msg.cWarningUserEnteredValidationDateTypeMessage02 + validValidationUserTypes.join(bas.cComa + bas.cSpace));
}
} // End-for (let validationTypesKey in validationTypesInputArray)
// validationTypesConfirmedArray is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationTypesConfirmedArrayIs + JSON.stringify(validationTypesConfirmedArray));
if (validationTypesConfirmedArray.length > 0) {
validationTypesConfirmedList = validationTypesConfirmedArray.join(bas.cComa);
validUserEntry = true;
} else {
// WARNING: No valid validation types were entered.
console.log(msg.cWarningUserEnteredValidationDataTypeMessage03);
// All validation types are:
console.log(msg.cWarningUserEnteredValidationDataTypeMessage02 + validValidationUserTypes.join(bas.cComa + bas.cSpace));
}
} else {
// User didn't enter any parameters at all....just run it all!
validationTypesConfirmedList = validValidationTypes.join(bas.cComa);
validationTypesConfirmedArray = validValidationTypes
validUserEntry = true;
}
// vaidationTypesConfirmedList is:
await loggers.consoleLog(namespacePrefix + functionName, msg.cvalidationTypesConfirmedListIs + validationTypesConfirmedList);
if (validUserEntry === true) {
let constantsValidationCommandToQueue = cmd.cvalidateConstants + bas.cSpace + validationTypesConfirmedList;
let commandAliasesValidationCommandToQueue = cmd.cvalidateCommandAliases + bas.cSpace + validationTypesConfirmedList;
let workflowsValidationCommandToQueue = cmd.cvalidateWorkflows + bas.cSpace + validationTypesConfirmedList;
if (await configurator.getConfigurationSetting(wrd.csystem, cfg.clogAllCommands) === true) {
await stack.push(sys.cSystemCommandLog, constantsValidationCommandToQueue);
await stack.push(sys.cSystemCommandLog, commandAliasesValidationCommandToQueue);
await stack.push(sys.cSystemCommandLog, workflowsValidationCommandToQueue);
}
// Now add them to the front of the command queue in reverse order, so they will get executed next.
// Running all validations
console.log(msg.cRunningAllValidationsMessage);
await queue.enqueueFront(sys.cCommandQueue, workflowsValidationCommandToQueue);
await queue.enqueueFront(sys.cCommandQueue, commandAliasesValidationCommandToQueue);
await queue.enqueueFront(sys.cCommandQueue, constantsValidationCommandToQueue);
}
await loggers.consoleLog(namespacePrefix + functionName, msg.creturnDataIs + JSON.stringify(returnData));
await loggers.consoleLog(namespacePrefix + functionName, msg.cEND_Function);
return returnData;
}
export default {
validateConstants,
validateCommandAliases,
validateWorkflows,
runAllValidations
}