@aj-shadow/z-abs-funclayer-engine-server 0.0.0-aj-beta.221

package/project/server/engine/test-case-loader.js

@@ -0,0 +1,125 @@
+
+'use strict';
+
+const DnsUrlCache = require('../address/dns-url-cache');
+const ExecutionContextTestCase = require('./execution-context-test-case');
+const LocalDns = require('../address/local-dns');
+const TestCase = require('./test-case');
+const TestOutput = require('./test-output');
+const ClientManager = require('../stack/managers/client-manager/client-manager');
+const ServerManager = require('../stack/managers/server-manager/server-manager');
+const SharedManager = require('../stack/managers/shared-manager');
+const StackContentCache = require('../stack/stacks/stack-content-cache');
+const ContentData = require('./data/content-data');
+const ContentCache = require('./data/content-cache');
+const TestCaseLoad = require('./test-case-load');
+const TestData = require('./data/test-data');
+const RuntimeDataShared = require('./data/runtime-data-shared');
+const Addresses = require('../address/addresses');
+const DebugDashboard = require('z-abs-funclayer-engine-server/server/debug-dashboard/debug-dashboard');
+const StackComponentsCerts = require('z-abs-funclayer-stack-server/server/factory/stack-components-certs');
+const StackComponentsFactory = require('z-abs-funclayer-stack-server/server/factory/stack-components-factory');
+const GuidGenerator = require('z-abs-corelayer-cs/clientServer/guid-generator');
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const Fs = require('fs');
+
+
+class TestCaseLoader {
+  static load(repoName, sutName, futName, tcName, sutInstance, stagedNodes, debug, config, cbMessage, done) {
+    #BUILD_RELEASE_START
+    const executionContext = new ExecutionContextTestCase(debug);
+    #BUILD_RELEASE_STOP
+    #BUILD_DEBUG_START
+    const executionContext = new Proxy(new ExecutionContextTestCase(debug), {
+      set(obj, prop, value) {
+        if(undefined === Reflect.get(obj, prop)) {
+          ddb.warning(`member: "${prop}" is not defined in constructor.`);
+        }
+        return Reflect.set(obj, prop, value);
+      }
+    });
+    #BUILD_DEBUG_STOP
+    executionContext.setStageData('_BASE', sutName, sutInstance, stagedNodes);
+    executionContext.setTestData(sutName, sutInstance);
+    executionContext.config = config;
+    
+    let pendings = 0;
+    let errorResponse = false;
+    const loadDone = (err, testCase) => {
+      if(!errorResponse) {
+        if(err) {
+          errorResponse = true;
+          done(err);
+        }
+        else if(0 === --pendings) {
+          executionContext.outputs.load();
+          testCase.load((loadErr) => {
+            done(loadErr, testCase);
+          });
+        }
+      }
+    };
+    let onTestDataLoaded = null;
+    let testCase = null;
+    ++pendings;
+    Fs.readFile(ActorPathData.getTestCaseFile(repoName, sutName, futName, tcName), (err, data) => {
+      if(!err) {
+        const tc = JSON.parse(data);
+        testCase = new TestCase(tc, [sutName, futName, tcName], 0, debug, executionContext, cbMessage);
+        if(testCase.containsInterceptor()) {
+          if(executionContext.testData.loaded) {
+            if(!StackComponentsFactory.supportInterceting('puppeteer', 'client', executionContext.testData)) { // HARDCODED
+              err = new Error('N/A');
+            }
+          }
+          else {
+            onTestDataLoaded = () => {
+              if(!StackComponentsFactory.supportInterceting('puppeteer', 'client', executionContext.testData)) { // HARDCODED
+                loadDone(new Error('N/A'), testCase);
+              }
+              else {
+                loadDone(null, testCase);
+              }
+            };
+            return;
+          }
+        }
+      }
+      loadDone(err, testCase);
+    });
+    ++pendings;
+    executionContext.contentData.load((err) => {
+      loadDone(err, testCase);
+    });
+    ++pendings;
+    executionContext.testData.load((err) => {
+      if(!err) {
+        if(config.asService) {
+          executionContext.testData.setOverrideTestData('tc-state-timeout', {
+            type: 'value',
+            value: '0'
+          });
+        }
+        if(onTestDataLoaded) {
+          onTestDataLoaded();
+        }
+      }
+      loadDone(err, testCase);
+    });
+    ++pendings;
+    Addresses.load(executionContext.addresses, (err) => {
+      loadDone(err, testCase);
+    });
+    ++pendings;
+    LocalDns.load(executionContext.dnsUrlCache.localDns, (err) => {
+      loadDone(err, testCase);
+    });
+    ++pendings;
+    StackComponentsCerts.isLoaded((err) => {
+      loadDone(err, testCase);
+    });
+  }
+}
+
+
+module.exports = TestCaseLoader;

package/project/server/engine/test-case-not-found.js

@@ -0,0 +1,29 @@
+
+'use strict';
+
+const MessageTestCaseStarted = require('../communication/messages/messages-s-to-c/message-test-case-started');
+const MessageTestCaseStopped = require('../communication/messages/messages-s-to-c/message-test-case-stopped');
+const ActorResultConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-result-const');
+const HighResolutionTimestamp = require('z-abs-corelayer-server/server/high-resolution-timestamp');
+
+
+class TestCaseNotFound {
+  constructor(iterationTs, name, sutName, cbMessage) {
+    this.index = -1;
+    this.iterationTs = iterationTs;
+    this.name = name;
+    this.sutName = sutName;
+    this.cbMessage = cbMessage;
+  }
+  
+  run(cbDone) {
+    const timestamp = process.hrtime.bigint();
+    const msgTcStarted = new MessageTestCaseStarted(this.index, this.iterationTs, this.name, sutName, [], HighResolutionTimestamp.getHighResolutionDate(timestamp), false);
+    this.cbMessage(msgTcStarted, null, this.debug);
+    const msgTcStopped = new MessageTestCaseStopped(this.index, this.iterationTs, 0n, ActorResultConst.REFLECTION, ActorResultConst.NONE, ActorResultConst.NONE, ActorResultConst.NONE, true);
+    this.cbMessage(msgTcStopped, null, this.debug);
+    cbDone();
+  }
+}
+
+module.exports = TestCaseNotFound;

package/project/server/engine/test-case-result-type.js

@@ -0,0 +1,42 @@
+
+'use strict';
+
+
+class TestCaseResultType {
+  constructor() {
+    this.testCaseResultTypeIds = new Map();
+    for(let i = 0; i <= 7; ++i) {
+      this.testCaseResultTypeIds.set(TestCaseResultType.names[i], i);
+    }
+  }
+  
+  static getName(id) {
+    return TestCaseResultType.names[id];
+  }
+  
+ static getId(name) {
+    return this.testCaseResultTypeIds.get(name);
+  }
+}
+
+TestCaseResultType.names = [
+  'none',
+  'pre',
+  'exec',
+  'pre_exec',
+  'post',
+  'pre_post',
+  'exec_post',
+  'all'
+];
+
+TestCaseResultType.NONE = 0;
+TestCaseResultType.PRE = 1;
+TestCaseResultType.EXEC = 2;
+TestCaseResultType.PRE_EXEC = 3;
+TestCaseResultType.POST = 4;
+TestCaseResultType.PRE_POST = 5;
+TestCaseResultType.EXEC_POST = 6;
+TestCaseResultType.ALL = 7;
+
+module.exports = new TestCaseResultType();

package/project/server/engine/test-case.js

@@ -0,0 +1,417 @@
+
+'use strict';
+
+
+const MessageExecutionStared = require('../communication/messages/messages-s-to-c/message-execution-started');
+const MessageTestCaseStarted = require('../communication/messages/messages-s-to-c/message-test-case-started');
+const MessageTestCaseStopped = require('../communication/messages/messages-s-to-c/message-test-case-stopped');
+const ActorStateMachine = require('./actor-state-machine');
+const Actors = require('./actors');
+const RuntimeDataShared = require('./data/runtime-data-shared');
+const TestCaseLoad = require('./test-case-load');
+const TestOutput = require('./test-output');
+const StackComponentsFactory = require('z-abs-funclayer-stack-server/server/factory/stack-components-factory');
+const ActorResultConst = require('z-abs-funclayer-engine-cs/clientServer/execution/actor-result-const');
+const HighResolutionTimestamp = require('z-abs-corelayer-server/server/high-resolution-timestamp');
+const MemoryCacheArray = require('z-abs-corelayer-cs/clientServer/memory/memory-cache-array');
+
+
+class TestCase {
+  static NOT_RUNNING_IN_TS = -1;
+  
+  constructor(tc, nameParams, iterationTs, debug, executionContext, cbMessage) {
+    this.uniqueTcId = 0n;
+    this.nameParams = nameParams;
+    this.tc = tc;
+    this.index = -1;
+    this.iterationTs = iterationTs;
+    this.kindOfRun = 0;
+    this.key = '';
+    this.debug = debug;
+    this.slowAwaitTime = {p: !executionContext.config.slow ? -1 : 250};
+    this.cbDone = null;
+    this.actors = null;
+    this.nodes = null;
+    this.executionContext = executionContext;
+    this.testCaseLoad = executionContext.testCaseLoad;
+    this.tcData = {
+      testDatasTestCase: new Map(),
+      testDatasTestCaseStatic: new Map(),
+      testDatasActor: new Map(),
+      verificationsTestCase: new Map(),
+      sharedRuntimeData: new RuntimeDataShared(),
+    };
+    this.cbMessage = cbMessage;
+    this.timestamp = null;
+       
+    this.iterationTc = 1;
+    this.actorStateMachine = new ActorStateMachine();
+    this.TcDataInitialized = false;
+  }
+  
+  getName() {
+    return this.tc.name;
+  }
+  
+  containsInterceptor() {
+    const actors = this.tc.tc.actors;
+    for(let i = 0; i < actors.length; ++i) {
+      if('inter' === actors[i].type) {
+        return true;
+      }
+    }
+    return false;
+  }
+  
+  load(cbResult) {
+    // TODO: restore instead of create.
+    this.tcData.sharedRuntimeData = new RuntimeDataShared();
+    this.uniqueTcId = this.executionContext.getUniqueId();
+    process.nextTick((self, Actors, cbResult) => {
+      self.kindOfRun = 0;
+      self.actors = new Actors(self.uniqueTcId, self.tc.tc, self.executionContext, self.tcData, self.debug, self.executionContext.config, self.slowAwaitTime, self.cbMessage);
+      self.actors.loadActors((result) => {
+        if(result) {
+          if(!self.TcDataInitialized) {
+            self.tcData.testDatasActor.set('pre', new Map());
+            self.tcData.testDatasActor.set('exec', new Map());
+            self.tcData.testDatasActor.set('post', new Map());
+            self._setTestDataTestCases(self.tc.tc.testDataTestCases);
+            self._setTestDataIteration(self.tc.tc.testDataIteration);
+            self._setVerificationTestCases(self.tc.tc.verificationTestCases);
+            const tcStaticData = self.getTestDataEngineBoolean('tc__staticData', false);
+            if(tcStaticData) {
+              self._setTestDatasTestCaseStatic(self.actors.preActors.actors, self.actors.execActors.actors, self.actors.postActors.actors);
+            }
+            self.TcDataInitialized = true;
+          }
+          self.nodes = self.actors.nodes;
+          self.actorStateMachine.init(self.tc, self.uniqueTcId, self.executionContext, self.actors, self.debug, self.cbMessage);
+          if(-1 !== self.slowAwaitTime.p) {
+            const slowAwaitTime = self.getTestDataEngineInteger('tc__SlowTime', self.slowAwaitTime);
+            self.slowAwaitTime.p = slowAwaitTime;
+          }
+          cbResult();
+        }
+        else {
+          cbResult(new Error('Error loading the Actors.'));
+        }
+      });
+    }, this, Actors, cbResult);
+  }
+  
+  _restoreActors(cbResult) {
+    this.load(cbResult);
+  }
+  
+  _run() {
+    this.timestamp = process.hrtime.bigint();
+    const msg = new MessageTestCaseStarted(this.index, this.iterationTs, this.tc.name, this.nameParams[0], this.actors.nodes, HighResolutionTimestamp.getHighResolutionDate(this.timestamp), true);
+    this.cbMessage(msg, null, this.debug);
+    this.actorStateMachine.run(this.sendSumResult.bind(this, this.index, this.iterationTs), this.cbDone);
+  }
+  
+  runDistributionStatic(cbDone) {
+    cbDone((commentOut, last) => {
+      this.actors.destructor();
+      this._restoreActors((err) => {
+        setTimeout((self) => {
+          self._run();
+        }, this.testCaseLoad.lambda, this);
+      });
+    });
+  }
+  
+  run(cbDone) {
+    this.cbDone = (done) => {
+      if(++this.iterationTc <= this.testCaseLoad.iterationsTc) {
+        done(false, false);
+        if(TestCaseLoad.EXECUTION_SERIAL === this.testCaseLoad.execution) {
+          if(TestCaseLoad.MODE_TC === this.testCaseLoad.mode) {
+            this.runDistributionStatic(cbDone);
+          }
+        }
+      }
+      else {
+        if(TestCase.NOT_RUNNING_IN_TS === this.index) {
+          cbDone((commentOut, last) => {
+            done(commentOut, last);
+            StackComponentsFactory.exitExecution(this.executionContext.executionData.id);
+            this.actors.destructor();
+          });
+        }
+        else {
+          const result = done(false, true);
+          cbDone(result);
+          this.actors.destructor();
+        }
+      }
+    };
+    if(TestCase.NOT_RUNNING_IN_TS === this.index) {
+      StackComponentsFactory.initExecution(this.executionContext.executionData.id, this.executionContext.debugDashboard);
+      const outputs = this.executionContext.outputs;
+      const msg = new MessageExecutionStared(outputs.chosen, outputs.chosenClient, outputs.chosenClientConsole);
+      this.cbMessage(msg, null, this.debug);
+    }
+    this._run();
+  }
+  
+  runCommentOut(cbDone) {
+    this.cbDone = (done) => {
+      done(true);
+      cbDone(ActorResultConst.NONE);
+    };
+    this.timestamp = process.hrtime.bigint();
+    const msg = new MessageTestCaseStarted(this.index, this.iterationTs, this.tc.name, this.nameParams[0], this.actors.nodes, HighResolutionTimestamp.getHighResolutionDate(this.timestamp), false);
+    this.cbMessage(msg, null, this.debug);
+    this.actorStateMachine.runCommentOut(this.sendSumResult.bind(this, this.index, this.iterationTs), this.cbDone);
+  }
+    
+  stop(done) {
+    this.actorStateMachine.stop(done);
+  }
+  
+  actorDebugContinue(index) {
+    this.actors.actors[index].debugContinue();
+  }
+  
+  getTestDataEngineString(key, defaultValue) {
+    const valueData = this._getTestDataEngine(key);
+    if(undefined !== valueData) {
+      return valueData.value;
+    }
+    else {
+      return defaultValue;
+    }
+  }
+  
+  getTestDataEngineInteger(key, defaultValue) {
+    const valueData = this._getTestDataEngine(key);
+    if(undefined !== valueData) {
+      return Number.parseInt(valueData.value);
+    }
+    else {
+      return defaultValue;
+    }
+  }
+  
+  getTestDataEngineBoolean(key, defaultValue) {
+    const valueData = this._getTestDataEngine(key);
+    if(undefined !== valueData) {
+      if('true' === valueData.value) {
+        return true;
+      }
+      else if('false' === valueData.value) {
+        return false;
+      }
+      else {
+        return undefined;
+      }
+    }
+    else {
+      return defaultValue;
+    }
+  }
+    
+  _getTestDataEngine(key) {
+    let valueData = this.tcData.testDatasTestCase.get(key);
+    if(undefined === valueData) {
+      valueData = this.executionContext.testData.getTestData(key, (key) => {
+        return this.tcData.testDatasTestCaseStatic.get(key);
+      });
+    }
+    if(undefined !== valueData) {
+      return valueData;
+    }
+  }
+  
+  sendSumResult(index, iterationTs, resultId, preResultId, execResultId, postResultId, last) {
+    const duration = process.hrtime.bigint() - this.timestamp;
+    const msg = new MessageTestCaseStopped(index, iterationTs, duration, resultId, preResultId, execResultId, postResultId, last);
+    this.cbMessage(msg, null, this.debug);
+    if(TestOutput.LOG_CONSOLE & this.executionContext.outputs.chosen) {
+      if(TestOutput.LOG_DETAIL_TC & this.executionContext.outputs.chosenConsole) {
+        if(TestCase.NOT_RUNNING_IN_TS === index) {
+          ddb.print(ActorResultConst.RESULTS_CONSOLE[resultId], this.nameParams[2]);
+        }
+        else {
+          const indexText = (index + 1).toString().padStart(4);
+          const iterationTsText = iterationTs.toString().padStart(3);
+          ddb.print(ddb.yellow(indexText), ddb.yellow(iterationTsText), ActorResultConst.RESULTS_CONSOLE[resultId], this.nameParams[2]);
+        }
+      }
+      if(TestOutput.LOG_DETAIL_ERR & this.executionContext.outputs.chosenConsole) {
+        if(TestCase.NOT_RUNNING_IN_TS === index) {
+          const errorDatass = this.executionContext.testCaseStatistics.errorDatass;
+          errorDatass.forEach((errorDatas) => {
+            errorDatas.forEach((errorData) => {
+              errorData.errorData.forEach((data) => {
+                if(data) {
+                  ddb.print(ddb.green(errorData.name + '[') + errorData.id + ddb.green(']'), data.action);
+                }
+              });
+            });
+          });
+        }
+      }
+    }
+    return resultId;
+  }
+    
+  _setTestDatasTestCaseStatic(preActors, execActors, postActors) {
+    this.executionContext.testData.addTestDataEmptyArray('preActorNames', this.tcData.testDatasTestCaseStatic);
+    this.executionContext.testData.addTestDataEmptyArray('preActorInstanceIndices', this.tcData.testDatasTestCaseStatic);
+    this.executionContext.testData.addTestDataEmptyArray('execActorNames', this.tcData.testDatasTestCaseStatic);
+    this.executionContext.testData.addTestDataEmptyArray('execActorInstanceIndices', this.tcData.testDatasTestCaseStatic);
+    this.executionContext.testData.addTestDataEmptyArray('postActorNames', this.tcData.testDatasTestCaseStatic);
+    this.executionContext.testData.addTestDataEmptyArray('postActorInstanceIndices', this.tcData.testDatasTestCaseStatic);
+    
+    const preActorNames = this.tcData.testDatasTestCaseStatic.get('preActorNames');
+    const preActorInstanceIndices = this.tcData.testDatasTestCaseStatic.get('preActorInstanceIndices');
+    preActorNames.value = [];
+    preActorInstanceIndices.value = [];
+    preActors.forEach((actor) => {
+      preActorNames.value.push(actor.name);
+      preActorInstanceIndices.value.push(actor.instanceIndex);
+    });
+    
+    const execActorNames = this.tcData.testDatasTestCaseStatic.get('execActorNames');
+    const execActorInstanceIndices = this.tcData.testDatasTestCaseStatic.get('execActorInstanceIndices');
+    execActorNames.value = [];
+    execActorInstanceIndices.value = [];
+    execActors.forEach((actor) => {
+      execActorNames.value.push(actor.name);
+      execActorInstanceIndices.value.push(actor.instanceIndex);
+    });
+    
+    const postActorNames = this.tcData.testDatasTestCaseStatic.get('postActorNames');
+    const postActorInstanceIndices = this.tcData.testDatasTestCaseStatic.get('postActorInstanceIndices');
+    postActorNames.value = [];
+    postActorInstanceIndices.value = [];
+    postActors.forEach((actor) => {
+      postActorNames.value.push(actor.name);
+      postActorInstanceIndices.value.push(actor.instanceIndex);
+    });
+  }
+  
+  _setTestDataTestCases(testDataTestCases) {
+    if(undefined !== testDataTestCases && Array.isArray(testDataTestCases)) {
+      testDataTestCases.forEach((testDataTestCase) => {
+        const key = testDataTestCase.key; 
+        if(key.endsWith('[]')) {
+          const arrayName = key.substr(0, key.length - 2);
+          let valueData = this.tcData.testDatasTestCase.get(arrayName);
+          if(undefined === valueData) {
+            valueData = {
+              type: 'array',
+              value: []
+            };
+            this.tcData.testDatasTestCase.set(arrayName, valueData);
+          }
+          valueData.value.push(testDataTestCase.value);
+        }
+        else {
+          this.tcData.testDatasTestCase.set(testDataTestCase.key, {
+            type: 'value',
+            value: testDataTestCase.value
+          });
+        }
+      });
+    }
+  }
+  
+  _setTestDataIteration(testDataIteration) {
+    if(undefined !== testDataIteration && Array.isArray(testDataIteration)) {
+      testDataIteration.forEach((testDataActor) => {
+        const testDatasPhase = this.tcData.testDatasActor.get(testDataActor.phase);
+        if(undefined !== testDatasPhase) {
+          let testDatasType = testDatasPhase.get(testDataActor.type);
+          if(undefined === testDatasType) {
+            testDatasType = new Map();
+            testDatasPhase.set(testDataActor.type, testDatasType);
+          }
+          this._setTestDataIterationValue(testDatasType, testDataActor);
+        }
+      });
+    }
+  }
+  
+  _setTestDataIterationValue(testDatasType, testDataActor) {
+    const key = testDataActor.key; 
+    if(/\[(.*)\]$/.test(key)) {
+      const match = key.match(/\[(.*)\]$/);
+      if(null != match) {
+        const arrayName = key.substr(0, key.length - match[0].length);
+        let testDatasActor = testDatasType.get(arrayName);
+        if(undefined === testDatasActor) {
+          testDatasActor = {
+            currentIndex: 0,
+            values: []
+          };
+          testDatasType.set(arrayName, testDatasActor);
+        }
+        const valueArray = testDatasActor.values.find((data) => {
+          return data.name === key;
+        });
+        if(undefined === valueArray) {
+          valueArray = {
+            name: key,
+            type: 'array',
+            value: []
+          };
+        }
+        testDatasActor.values.push(valueArray);
+        valueArray.value.push(testDataActor.value);
+      }
+    }
+    else {
+      let testDatasActor = testDatasType.get(key);
+      if(undefined === testDatasActor) {
+        testDatasActor = {
+          currentIndex: 0,
+          values: []
+        };
+        testDatasType.set(key, testDatasActor);
+      }
+      testDatasActor.values.push({
+        type: 'value',
+        value: testDataActor.value
+      });
+    }
+  }
+  
+  _setVerificationTestCases(verificationTestCases) {
+    if(undefined !== verificationTestCases && Array.isArray(verificationTestCases)) {
+      verificationTestCases.forEach((verificationTestCase) => {
+        const key = verificationTestCase.key; 
+        if(key.endsWith('[]')) {
+          const arrayName = key.substr(0, key.length - 2);
+          let valueData = this.tcData.verificationsTestCase.get(arrayName);
+          if(undefined === valueData) {
+            valueData = {
+              type: 'array',
+              value: [],
+              operation: [],
+              valueType: []
+            };
+            this.tcData.verificationsTestCase.set(arrayName, valueData);
+          }
+          valueData.value.push(verificationTestCase.value); 
+          valueData.operation.push(0 === verificationTestCase.operation.length ? '===' : verificationTestCase.operation); 
+          valueData.valueType.push(0 === verificationTestCase.type.length ? 'string' : verificationTestCase.type); 
+        }
+        else {
+          this.tcData.verificationsTestCase.set(verificationTestCase.key, {
+            type: 'value',
+            value: verificationTestCase.value,
+            operation: 0 === verificationTestCase.operation.length ? '===' : verificationTestCase.operation,
+            valueType: 0 === verificationTestCase.type.length ? 'string' : verificationTestCase.type
+          });
+        }
+      });
+    }
+  }
+}
+
+
+module.exports = TestCase;