@haystacks/async/test/unitTest/plan/controllers/chiefPlugin.txt

A framework to build any number or any kind of native application or automation solution.

Description: Test plan for chiefPlugin.js

--------------------------------------------------------------------------------
testName: loadPluginRegistryData_validData
input pluginRegistryPath: string (This is the path to host application plugin registry file)
output: object (A JSON object loaded from the specified path with the plugin paths and plugin metaData)

testName: loadPluginRegistryData_inValidPluginRegistryPathString
input pluginRegistryPath: string (dfxg24346dfg)
output: ?

testName: loadPluginRegistryData_inValidPluginRegistryPathInteger
input pluginRegistryPath: integer (123)
output: ?

testName: loadPluginRegistryData_inValidPluginRegistryPathBoolean
input pluginRegistryPath: boolean (false)
output: ?

testName: loadPluginRegistryData_inValidPluginRegistryPathUndefined
input pluginRegistryPath: undefined
output: ?

testName: loadPluginRegistryData_inValidPluginRegistryPathNaN
input pluginRegistryPath: NaN
output: ?
--------------------------------------------------------------------------------
testName: persistPluginRegistryToDataStructure_validData
input pluginRegistryData: string (This is the data from host application plugin registry file)
output: object (True or False to indicate if the persistense was successful or not)

testName: persistPluginRegistryToDataStructure_inValidPluginRegistryDataString
input pluginRegistryData: string (dfxg24346dfg)
output: ?

testName: persistPluginRegistryToDataStructure_inValidPluginRegistryDataInteger
input pluginRegistryData: integer (123)
output: ?

testName: persistPluginRegistryToDataStructure_inValidPluginRegistryDataBoolean
input pluginRegistryData: boolean (false)
output: ?

testName: persistPluginRegistryToDataStructure_inValidPluginRegistryDataUndefined
input pluginRegistryData: undefined
output: ?

testName: persistPluginRegistryToDataStructure_inValidPluginRegistryDataNaN
input pluginRegistryData: NaN
output: ?
--------------------------------------------------------------------------------
testName: listLoadedPlugins_validData
output: array<string> (A list array of the names of the plugins that are currently loaded)
--------------------------------------------------------------------------------
testName: getAllPluginsInRegistry_validData
output: array<string> (A list array of the names of the plugins in the plugin registry)
--------------------------------------------------------------------------------
testName: getAllPluginsPathsInRegistry_validData
output: array<string> (A list array of all the paths of all the plugins in the plugin registry)
--------------------------------------------------------------------------------
testName: getAllPluginsInRegistryPath_validData
output: array<string> (A list array of the names of the plugins located at the specified path on the local system from the plugins registry data hive)
--------------------------------------------------------------------------------
testName: countAllPluginsInRegistry_validData
output: integer (The count of the number of plugins listed in the plugin registry data hive)
--------------------------------------------------------------------------------
testName: countAllPluginsInRegistryPath_validData
output: integer (The count of the number of plugin sub-folders in the plugins path listed in the plugin registry data hive)
--------------------------------------------------------------------------------
testName: registerNamedPlugin_validData
input pluginName: string (The name of the plugin that should be registered)
input pluginPath: string (The path to the plugin, to be added to the plugin registry)
output: boolean (True or False to indicate if the plugin was added to the plugin registry successfully or not)

testName: registerNamedPlugin_inValidPluginNameString
input pluginName: string (dfxg24346dfg)
input pluginPath: string (The path to the plugin, to be added to the plugin registry)
output: ?

testName: registerNamedPlugin_inValidPluginPathString
input pluginName: string (The name of the plugin that should be registered)
input pluginPath: string (dfxg24346dfg)
output: ?

testName: registerNamedPlugin_inValidPluginNameInteger
input pluginName: integer (123)
input pluginPath: string (The path to the plugin, to be added to the plugin registry)
output: ?

testName: registerNamedPlugin_inValidPluginNameBoolean
input pluginName: boolean (false)
input pluginPath: string (The path to the plugin, to be added to the plugin registry)
output: ?

testName: registerNamedPlugin_inValidPluginPathInteger
input pluginName: string (The name of the plugin that should be registered)
input pluginPath: integer (123)
output: ?

testName: registerNamedPlugin_inValidPluginPathBoolean
input pluginName: string (The name of the plugin that should be registered)
input pluginPath: boolean (false)
output: ?

testName: registerNamedPlugin_inValidPluginNameUndefined
input pluginName: undefined
input pluginPath: string (The path to the plugin, to be added to the plugin registry)
output: ?

testName: registerNamedPlugin_inValidPluginNameNaN
input pluginName: NaN
input pluginPath: string (The path to the plugin, to be added to the plugin registry)
output: ?

testName: registerNamedPlugin_inValidPluginPathUndefined
input pluginName: string (The name of the plugin that should be registered)
input pluginPath: undefined
output: ?

testName: registerNamedPlugin_inValidPluginPathNaN
input pluginName: string (The name of the plugin that should be registered)
input pluginPath: NaN
output: ?
--------------------------------------------------------------------------------
testName: unregisterNamedPlugin_validData
input pluginName: string (The name of the plugin that should be removed from the plugin registry)
output: boolean (True or False to indicate if the plugin was removed from the plugin registry successfully or not)

testName: unregisterNamedPlugin_inValidPluginNameString
input pluginName: string (dfxg24346dfg)
output: ?

testName: unregisterNamedPlugin_inValidPluginNameInteger
input pluginName: integer (123)
output: ?

testName: unregisterNamedPlugin_inValidPluginNameBoolean
input pluginName: boolean (false)
output: ?

testName: unregisterNamedPlugin_inValidPluginNameUndefined
input pluginName: undefined
output: ?

testName: unregisterNamedPlugin_inValidPluginNameNaN
input pluginName: NaN
output: ?
--------------------------------------------------------------------------------
testName: unregisterPlugins_validData
input pluginListArray: array<string> (A list array of plugin names that should be removed from the plugin registry)
output: boolean (True or False to indicate if all the plugins were removed from the plugin registry successfully or not)

testName: unregisterPlugins_inValidPluginListArrayString
input pluginListArray: string (dfxg24346dfg)
output: ?

testName: unregisterPlugins_inValidPluginListArrayInteger
input pluginListArray: integer (123)
output: ?

testName: unregisterPlugins_inValidPluginListArrayBoolean
input pluginListArray: boolean (false)
output: ?

testName: unregisterPlugins_inValidPluginListArrayUndefined
input pluginListArray: undefined
output: ?

testName: unregisterPlugins_inValidPluginListArrayNaN
input pluginListArray: NaN
output: ?
--------------------------------------------------------------------------------
testName: synchronizePluginRegistryWithPath_validData
output: boolean (True or False to indicate if the synchronization was performed successfully or not)
--------------------------------------------------------------------------------
testName: clearPluginRegistry_validData
output: boolean (True or False to indicate if the plugin registry data hive was cleared successfully or not)
--------------------------------------------------------------------------------
testName: savePluginRegistryDisk_validData
output: boolean (True or False to indicate if the plugin registry was successfully saved to the disk or not)
--------------------------------------------------------------------------------
testName: loadAllPluginsMetaData_validData
input pluginsPaths: array<string> (Should be the entry-point to the plugin, but it could also be the name of the folder in the plugin registry path that is the entry-point to the plugin)
output: array<string> (An array that contains all of the meta-data, for each of the plugins in the input pluginsPaths array)

testName: loadAllPluginsMetaData_inValidPluginsPathsString
input pluginsPaths: string (dfxg24346dfg)
output: ?

testName: loadAllPluginsMetaData_inValidPluginsPathsInteger
input pluginsPaths: integer (123)
output: ?

testName: loadAllPluginsMetaData_inValidPluginsPathsBoolean
input pluginsPaths: boolean (false)
output: ?

testName: loadAllPluginsMetaData_inValidPluginsPathsUndefined
input pluginsPaths: undefined
output: ?

testName: loadAllPluginsMetaData_inValidPluginsPathsNaN
input pluginsPaths: NaN
output: ?
--------------------------------------------------------------------------------
testName: loadAllPluginsExecutionPaths_validData
input pluginsMetaData: array<object> (An array of JSON objects that contain all of the package.json data loaded for each plugin that should be imported)
input pluginsPaths: array<string> (An array of fully qualified paths where each plugin was loaded from, used to path.join with the execution path entry point file for each plugin)
output: array<string> (An array of fully qualified path URI's for each of the main entry points for all of the plugins that should be loaded)

testName: loadAllPluginsExecutionPaths_inValidPluginsMetaDataString
input pluginsMetaData: string (dfxg24346dfg)
input pluginsPaths: array<string> (An array of fully qualified paths where each plugin was loaded from, used to path.join with the execution path entry point file for each plugin)
output: ?

testName: loadAllPluginsExecutionPaths_inValidPluginsPathsString
input pluginsMetaData: array<object> (An array of JSON objects that contain all of the package.json data loaded for each plugin that should be imported)
input pluginsPaths: string (dfxg24346dfg)
output: ?

testName: loadAllPluginsExecutionPaths_inValidPluginsMetaDataInteger
input pluginsMetaData: integer (123)
input pluginsPaths: array<string> (An array of fully qualified paths where each plugin was loaded from, used to path.join with the execution path entry point file for each plugin)
output: ?

testName: loadAllPluginsExecutionPaths_inValidPluginsMetaDataBoolean
input pluginsMetaData: boolean (false)
input pluginsPaths: array<string> (An array of fully qualified paths where each plugin was loaded from, used to path.join with the execution path entry point file for each plugin)
output: ?

testName: loadAllPluginsExecutionPaths_inValidPluginsPathsInteger
input pluginsMetaData: array<object> (An array of JSON objects that contain all of the package.json data loaded for each plugin that should be imported)
input pluginsPaths: integer (123)
output: ?

testName: loadAllPluginsExecutionPaths_inValidPluginsPathsBoolean
input pluginsMetaData: array<object> (An array of JSON objects that contain all of the package.json data loaded for each plugin that should be imported)
input pluginsPaths: boolean (false)
output: ?

testName: loadAllPluginsExecutionPaths_inValidPluginsMetaDataUndefined
input pluginsMetaData: undefined
input pluginsPaths: array<string> (An array of fully qualified paths where each plugin was loaded from, used to path.join with the execution path entry point file for each plugin)
output: ?

testName: loadAllPluginsExecutionPaths_inValidPluginsMetaDataNaN
input pluginsMetaData: NaN
input pluginsPaths: array<string> (An array of fully qualified paths where each plugin was loaded from, used to path.join with the execution path entry point file for each plugin)
output: ?

testName: loadAllPluginsExecutionPaths_inValidPluginsPathsUndefined
input pluginsMetaData: array<object> (An array of JSON objects that contain all of the package.json data loaded for each plugin that should be imported)
input pluginsPaths: undefined
output: ?

testName: loadAllPluginsExecutionPaths_inValidPluginsPathsNaN
input pluginsMetaData: array<object> (An array of JSON objects that contain all of the package.json data loaded for each plugin that should be imported)
input pluginsPaths: NaN
output: ?
--------------------------------------------------------------------------------
testName: loadAllPlugins_validData
input pluginsExecutionPaths: array<string> (An array of fully qualified path URI's to be imported and executed for each plugin)
input pluginsMetaData: array<object> (An array of JSON objects that contain all of the package.json data loaded for each plugin that should be imported, we are passing this along here, to have access to the name of each plugin as it is loaded)
output: object (An object containing objects that contain all of the data and functions from each plugin, these will need to be decomposed and merged with the D-data structure as appropriate)

testName: loadAllPlugins_inValidPluginsExecutionPathsString
input pluginsExecutionPaths: string (dfxg24346dfg)
input pluginsMetaData: array<object> (An array of JSON objects that contain all of the package.json data loaded for each plugin that should be imported, we are passing this along here, to have access to the name of each plugin as it is loaded)
output: ?

testName: loadAllPlugins_inValidPluginsMetaDataString
input pluginsExecutionPaths: array<string> (An array of fully qualified path URI's to be imported and executed for each plugin)
input pluginsMetaData: string (dfxg24346dfg)
output: ?

testName: loadAllPlugins_inValidPluginsExecutionPathsInteger
input pluginsExecutionPaths: integer (123)
input pluginsMetaData: array<object> (An array of JSON objects that contain all of the package.json data loaded for each plugin that should be imported, we are passing this along here, to have access to the name of each plugin as it is loaded)
output: ?

testName: loadAllPlugins_inValidPluginsExecutionPathsBoolean
input pluginsExecutionPaths: boolean (false)
input pluginsMetaData: array<object> (An array of JSON objects that contain all of the package.json data loaded for each plugin that should be imported, we are passing this along here, to have access to the name of each plugin as it is loaded)
output: ?

testName: loadAllPlugins_inValidPluginsMetaDataInteger
input pluginsExecutionPaths: array<string> (An array of fully qualified path URI's to be imported and executed for each plugin)
input pluginsMetaData: integer (123)
output: ?

testName: loadAllPlugins_inValidPluginsMetaDataBoolean
input pluginsExecutionPaths: array<string> (An array of fully qualified path URI's to be imported and executed for each plugin)
input pluginsMetaData: boolean (false)
output: ?

testName: loadAllPlugins_inValidPluginsExecutionPathsUndefined
input pluginsExecutionPaths: undefined
input pluginsMetaData: array<object> (An array of JSON objects that contain all of the package.json data loaded for each plugin that should be imported, we are passing this along here, to have access to the name of each plugin as it is loaded)
output: ?

testName: loadAllPlugins_inValidPluginsExecutionPathsNaN
input pluginsExecutionPaths: NaN
input pluginsMetaData: array<object> (An array of JSON objects that contain all of the package.json data loaded for each plugin that should be imported, we are passing this along here, to have access to the name of each plugin as it is loaded)
output: ?

testName: loadAllPlugins_inValidPluginsMetaDataUndefined
input pluginsExecutionPaths: array<string> (An array of fully qualified path URI's to be imported and executed for each plugin)
input pluginsMetaData: undefined
output: ?

testName: loadAllPlugins_inValidPluginsMetaDataNaN
input pluginsExecutionPaths: array<string> (An array of fully qualified path URI's to be imported and executed for each plugin)
input pluginsMetaData: NaN
output: ?
--------------------------------------------------------------------------------
testName: integrateAllPluginsData_validData
input allPluginsData: object (All of the plugins data for each plugin all combined together into a single JSON data object)
output: boolean (?)

testName: integrateAllPluginsData_inValidAllPluginsDataString
input allPluginsData: string (dfxg24346dfg)
output: ?

testName: integrateAllPluginsData_inValidAllPluginsDataInteger
input allPluginsData: integer (123)
output: ?

testName: integrateAllPluginsData_inValidAllPluginsDataBoolean
input allPluginsData: boolean (false)
output: ?

testName: integrateAllPluginsData_inValidAllPluginsDataUndefined
input allPluginsData: undefined
output: ?

testName: integrateAllPluginsData_inValidAllPluginsDataNaN
input allPluginsData: NaN
output: ?
--------------------------------------------------------------------------------
testName: integratePluginData_validData
input pluginName: string (The name of the plugin that should have its data integrated with the haystacks data structure)
input pluginData: object (The data for the named plugin that should be integrated wtih the haystacks data structure)
output: boolean (True or False to indicate if all the plugin data was integrated successfully with the haystacks data structures)

testName: integratePluginData_inValidPluginNameString
input pluginName: string (dfxg24346dfg)
input pluginData: object (The data for the named plugin that should be integrated wtih the haystacks data structure)
output: ?

testName: integratePluginData_inValidPluginDataString
input pluginName: string (The name of the plugin that should have its data integrated with the haystacks data structure)
input pluginData: string (dfxg24346dfg)
output: ?

testName: integratePluginData_inValidPluginNameInteger
input pluginName: integer (123)
input pluginData: object (The data for the named plugin that should be integrated wtih the haystacks data structure)
output: ?

testName: integratePluginData_inValidPluginNameBoolean
input pluginName: boolean (false)
input pluginData: object (The data for the named plugin that should be integrated wtih the haystacks data structure)
output: ?

testName: integratePluginData_inValidPluginDataInteger
input pluginName: string (The name of the plugin that should have its data integrated with the haystacks data structure)
input pluginData: integer (123)
output: ?

testName: integratePluginData_inValidPluginDataBoolean
input pluginName: string (The name of the plugin that should have its data integrated with the haystacks data structure)
input pluginData: boolean (false)
output: ?

testName: integratePluginData_inValidPluginNameUndefined
input pluginName: undefined
input pluginData: object (The data for the named plugin that should be integrated wtih the haystacks data structure)
output: ?

testName: integratePluginData_inValidPluginNameNaN
input pluginName: NaN
input pluginData: object (The data for the named plugin that should be integrated wtih the haystacks data structure)
output: ?

testName: integratePluginData_inValidPluginDataUndefined
input pluginName: string (The name of the plugin that should have its data integrated with the haystacks data structure)
input pluginData: undefiend
output: ?

testName: integratePluginData_inValidPluginDataNaN
input pluginName: string (The name of the plugin that should have its data integrated with the haystacks data structure)
input pluginData: NaN
output: ?
--------------------------------------------------------------------------------
testName: verifyAllPluginsLoaded_validData
output: boolean (True or False to indicate if all of the plugins were loaded successfully or not)
--------------------------------------------------------------------------------
testName: unloadPlugin_validData
input pluginName: string (The name of the plugin that should have all its data unloaded from the D-data structure)
output: boolean (True or False to indicate if the plugin was unloaded successfully or not)

testName: unloadPlugin_inValidPluginNameString
input pluginName: string (dfxg24346dfg)
output: ?

testName: unloadPlugin_inValidPluginNameInteger
input pluginName: integer (123)
output: ?

testName: unloadPlugin_inValidPluginNameBoolean
input pluginName: boolean (false)
output: ?

testName: unloadPlugin_inValidPluginNameUndefined
input pluginName: undefined
output: ?

testName: unloadPlugin_inValidPluginNameNaN
input pluginName: NaN
output: ?
--------------------------------------------------------------------------------
testName: getPluginsRegistryPath_validData
output: string (The path to the plugins listed in the plugin registry as meta-data)