@aj-shadow/z-abs-complayer-markup-client 0.0.0-aj-beta.221

package/project/client/data/data-system-under-test/data-system-under-test-instances.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataSystemUnderTestInstances extends DataTableKeyValue {
+  constructor(name, description) {
+    super();
+    this.name = name;
+    this.description = description;
+  }
+}
+
+module.exports = DataSystemUnderTestInstances;

package/project/client/data/data-system-under-test/data-system-under-test-nodes.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataSystemUnderTestNodes extends DataTableKeyValue {
+  constructor(name, instanceName, criteriaType, criteria, description) {
+    super();
+    this.name = name;
+    this.instanceName = instanceName;
+    this.criteriaType = criteriaType;
+    this.criteria = criteria;
+    this.description = description;
+  }
+}
+
+module.exports = DataSystemUnderTestNodes;

package/project/client/data/data-table/data-table-config.js

@@ -0,0 +1,21 @@
+
+'use strict';
+
+const DataConfig = require('../data-config');
+
+
+class DataConfigTable extends DataConfig {
+  constructor() {
+    super();
+    this.classHeading = '';
+  }
+  
+  addConfig(name, value) {
+    const member = this[name];
+    if(undefined !== member) {
+      this[name] = value;
+    }
+  }
+}
+
+module.exports = DataConfigTable;

package/project/client/data/data-table-key-value.js

@@ -0,0 +1,56 @@
+
+'use strict';
+
+
+class DataTableKeyValue {
+  constructor(defaultValues, allowedValues) {
+    this._defaultValues = new Map(defaultValues);
+    this._allowedValues = new Map(allowedValues);
+  }
+  
+  getName() {
+    return this.constructor.name.substr(4);
+  }
+  
+  getHeadings() {
+    const headings = Object.keys(this);
+    const filteredHeadings = headings.filter((value) => {
+      return !value.startsWith('_');
+    });    
+    return filteredHeadings;
+  }
+
+  getValue(heading, rowData) {
+    let value = rowData[heading];
+    let style = {color:'black'};
+    if(undefined === value || '' === value) {
+      let defaultFunction = this._defaultValues.get(heading);
+      if(undefined !== defaultFunction) {
+        value = defaultFunction(rowData);
+        rowData[heading] = value;
+        style = {color:'#009933'};
+      }
+    }
+    let allowedFunction = this._allowedValues.get(heading);
+    if(undefined !== allowedFunction) {
+      switch(allowedFunction(rowData)) {
+        case DataTableKeyValue.ALLOWED_NOK_VALUE:
+          style = {color:'red'};
+          break;
+        case DataTableKeyValue.ALLOWED_NOK_COMBO:
+          style = {color:'orange'};
+          break;
+      }
+    }
+    return {
+      value: value,
+      style: style
+    }
+  }
+}
+
+DataTableKeyValue.ALLOWED_OK = 0;
+DataTableKeyValue.ALLOWED_NOK_VALUE = 1;
+DataTableKeyValue.ALLOWED_NOK_COMBO = 2;
+
+module.exports = DataTableKeyValue;

package/project/client/data/data-test-case/data-actor.js

@@ -0,0 +1,282 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataActor extends DataTableKeyValue {
+  constructor(name, node, type, phase, execution, src, dst, srv, testData, verification) {
+    super([
+      ['phase', (rowData) => {return this._defaultPhase(rowData);}],
+      ['execution', (rowData) => {return this._defaultExecution(rowData);}]
+    ],
+    [
+      ['type', (rowData) => {
+        switch(rowData.type) {
+          case 'orig':
+          case 'term':
+          case 'inter':
+          case 'proxy':
+          case 'sut':
+          case 'local':
+            return DataTableKeyValue.ALLOWED_OK;
+          case 'cond':
+            switch(rowData.phase) {
+              case '':
+              case 'pre, post':
+                return DataTableKeyValue.ALLOWED_OK;
+              default:
+                return DataTableKeyValue.ALLOWED_NOK_COMBO;
+            }
+          default:
+            return DataTableKeyValue.ALLOWED_NOK_VALUE;
+        }
+      }],
+      ['phase', (rowData) => {
+        switch(rowData.phase) {
+          case 'pre':
+          case 'exec':
+          case 'post':
+            if('cond' === rowData.type) {
+              return DataTableKeyValue.ALLOWED_NOK_COMBO;
+            }
+            else {
+              return DataTableKeyValue.ALLOWED_OK;
+            }
+          case 'pre, post':
+          case '':
+            if('cond' === rowData.type) {
+              return DataTableKeyValue.ALLOWED_OK;
+            }
+            else {
+              return DataTableKeyValue.ALLOWED_NOK_COMBO;
+            }
+          default:
+            return DataTableKeyValue.ALLOWED_NOK_VALUE;
+        }
+      }],
+      ['execution', (rowData) => {
+        switch(rowData.execution) {
+          case 'serial':
+          case 'parallel':
+            return DataTableKeyValue.ALLOWED_OK;
+          default:
+            return DataTableKeyValue.ALLOWED_NOK_VALUE;
+        }
+      }],
+      ['src', (rowData) => {return this._allowedAddressNames(rowData.src, 'src');}],
+      ['dst', (rowData) => {return this._allowedAddressNames(rowData.dst, 'dst');}],
+      ['srv', (rowData) => {return this._allowedAddressNames(rowData.srv, 'srv');}],
+      ['testData', (rowData) => {return this._allowedTestData(rowData);}],
+      ['verification', (rowData) => {return this._allowedVerification(rowData);}]
+    ]);
+    this.name = name;
+    this.node = node;
+    this.type = type;
+    this.phase = phase;
+    this.execution = execution;
+    this.src = src;
+    this.dst = dst;
+    this.srv = srv;
+    this.testData = testData;
+    this.verification = verification;
+    this._phaseDefault = null;
+    this._phaseExecution = null;
+  }
+  
+  getValue(heading, rowData) {
+    if('name' !== heading) {
+      return super.getValue(heading, rowData);
+    }
+    else {
+      let value = super.getValue(heading, rowData);
+      let actorPaths = value.value.split('.');
+      value.link = `/actor-editor/${actorPaths.join('/')}.js`
+      return value;
+    } 
+  }
+  
+  _defaultPhase(rowData) {
+    if('cond' === rowData.type) {
+      this._phaseDefault = 'pre, post';
+      return 'pre, post';
+    }
+    else {
+      this._phaseDefault = 'exec';
+      return 'exec';
+    }
+  }
+  
+  _defaultExecution(rowData) {
+    if('orig' === rowData.type || 'cond' === rowData.type || 'local' === rowData.type) {
+      this._phaseExecution = 'serial';
+      return 'serial';
+    }
+    else {
+      this._phaseExecution = 'parallel';
+      return 'parallel';
+    }
+  }
+  
+  _allowedTestData(rowData) {
+    if(undefined === rowData.testData || '' === rowData.testData) {
+      return DataTableKeyValue.ALLOWED_OK;
+    }
+    else {
+      try {
+        let testDataActors = JSON.parse(rowData.testData);
+        if(Array.isArray(testDataActors) && testDataActors.length >= 1) {
+          let formatOk = true;
+          testDataActors.forEach((testDataActor) => {
+            if(Array.isArray(testDataActor)) {
+              if(2 !== testDataActor.length && 3 !== testDataActor.length) {
+                formatOk = false;
+              }
+            }
+            else {
+              formatOk = false;
+            }
+          });
+          if(formatOk) {
+            return DataTableKeyValue.ALLOWED_OK;
+          }
+          else {
+            return DataTableKeyValue.ALLOWED_NOK_VALUE;
+          }
+        }
+      }
+      catch(err) {
+      }
+      return DataTableKeyValue.ALLOWED_NOK_VALUE;
+    }
+  }
+  
+  _allowedVerification(rowData) {
+    if(undefined === rowData.verification || '' === rowData.verification) {
+      return DataTableKeyValue.ALLOWED_OK;
+    }
+    else {
+      try {
+        let verificationActors = JSON.parse(rowData.verification);
+        if(Array.isArray(verificationActors) && verificationActors.length >= 1) {
+          let formatOk = true;
+          verificationActors.forEach((verificationActor) => {
+            if(Array.isArray(verificationActor)) {
+              if(2 !== verificationActor.length && 3 !== verificationActor.length) {
+                formatOk = false;
+              }
+            }
+            else {
+              formatOk = false;
+            }
+          });
+          if(formatOk) {
+            return DataTableKeyValue.ALLOWED_OK;
+          }
+          else {
+            return DataTableKeyValue.ALLOWED_NOK_VALUE;
+          }
+        }
+      }
+      catch(err) {
+      }
+      return DataTableKeyValue.ALLOWED_NOK_VALUE;
+    }
+  }
+
+  _allowedAddressName(addressName, type) {
+    if(typeof addressName === 'string') {
+      if('' === addressName) {
+        return DataTableKeyValue.ALLOWED_OK;
+      }
+      else {
+        try {
+          const testDataAddressNames = JSON.parse(addressName);
+          if(Array.isArray(testDataAddressNames) && testDataAddressNames.length >= 1) {
+            for(let i = 0; i < testDataAddressNames.length; ++i) {
+              if('string' !== typeof testDataAddressNames[i]) {
+                return DataTableKeyValue.ALLOWED_NOK_VALUE; 
+              }
+              const notAllowedSigns = testDataAddressNames[i].replace(/\w/g, '');
+              if(0 !== notAllowedSigns.length) {
+                return DataTableKeyValue.ALLOWED_NOK_VALUE;
+              }    
+            }
+            return DataTableKeyValue.ALLOWED_OK;
+          }
+          else if(typeof testDataAddressNames === 'object') {
+            const obj = testDataAddressNames;
+            if(undefined !== obj.host && '' !== obj.host) {
+              // TODO: Verify correct host name.
+              return DataTableKeyValue.ALLOWED_OK;
+            }
+            else if(undefined !== obj.uri && '' !== obj.uri) {
+              // TODO: Verify correct uri.
+              return DataTableKeyValue.ALLOWED_OK;
+            }
+            else {
+              return DataTableKeyValue.ALLOWED_NOK_VALUE;
+            }
+          }
+        }
+        catch(err) {
+          const notAllowedSigns = addressName.replace(/\w/g, '');
+          if(0 === notAllowedSigns.length) {
+            return DataTableKeyValue.ALLOWED_OK;
+          }
+        }
+        return DataTableKeyValue.ALLOWED_NOK_VALUE;
+      }
+    }
+    else if(Array.isArray(addressName) && 'dst' === type) {
+      if(2 === addressName.length) {
+        if(DataTableKeyValue.ALLOWED_OK === this._allowedAddressName(addressName[0], type) && DataTableKeyValue.ALLOWED_OK === this._allowedAddressName(addressName[1], type)) {
+          return DataTableKeyValue.ALLOWED_OK;
+        }
+        else {
+          return DataTableKeyValue.ALLOWED_NOK_VALUE;
+        }
+      }
+      else {
+         return DataTableKeyValue.ALLOWED_NOK_VALUE;
+      }
+    }
+    else {
+      return DataTableKeyValue.ALLOWED_NOK_VALUE;
+    }
+  }
+  
+  _allowedAddressNames(addressName, type) {
+    if(undefined === addressName) {
+      return DataTableKeyValue.ALLOWED_OK;
+    }
+    else {
+      let addresses = null;
+      try {
+        addresses = JSON.parse(addressName);
+      }
+      catch(err) {}
+      if(Array.isArray(addresses)) {
+        const results = [];
+        addresses.forEach((address) => { 
+          results.push(this._allowedAddressName(address, type));
+        });
+        const first = results[0];
+        const allEqual = results.every((result) => {
+          return first === result;
+        });
+        if(allEqual && DataTableKeyValue.ALLOWED_OK === first) {
+          return DataTableKeyValue.ALLOWED_OK;
+        }
+        else {
+          return DataTableKeyValue.ALLOWED_NOK_VALUE;
+        }
+      }
+      else {
+        return this._allowedAddressName(addressName, type);
+      }
+    }
+  }
+}
+
+module.exports = DataActor;

package/project/client/data/data-test-case/data-test-case-settings.js

@@ -0,0 +1,49 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataTestCaseSettings extends DataTableKeyValue {
+  constructor(preResult, execResult, postResult) {
+    super([
+      ['preResult', (rowData) => {return 'success'}],
+      ['execResult', (rowData) => {return 'success'}],
+      ['postResult', (rowData) => {return 'success'}]
+    ],
+    [
+      ['preResult', (rowData) => {
+        return this.getAllowedResult(rowData.preResult);
+      }],
+      ['execResult', (rowData) => {
+        return this.getAllowedResult(rowData.execResult);
+      }],
+      ['postResult', (rowData) => {
+        return this.getAllowedResult(rowData.postResult);
+      }]
+    ]);
+    this.preResult = preResult;
+    this.execResult = execResult;
+    this.postResult = postResult;
+  }
+  
+  getAllowedResult(resultId) {
+    switch(resultId) {
+      case 'none':
+      case 'n/a':
+      case 'n_impl':
+      case 'success':
+      case 'n_exec':
+      case 'interrupt':
+      case 'failure':
+      case 'error':
+      case 'timeout':
+      case 'reflection':
+        return DataTableKeyValue.ALLOWED_OK;
+      default:
+        return DataTableKeyValue.ALLOWED_NOK_VALUE;
+    }
+  }
+}
+
+module.exports = DataTestCaseSettings;

package/project/client/data/data-test-case/data-test-case.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+
+class DataTestCase {
+  constructor(settings = [], actors = [], testDataTestCases = [], testDataIteration = [], verificationTestCases = []) {
+    this.settings = settings;
+    this.actors = actors;
+    this.testDataTestCases = testDataTestCases;
+    this.testDataIteration = testDataIteration;
+    this.verificationTestCases = verificationTestCases;
+  }
+  
+  addActor(actor) {
+    this.actors.push(actor);
+  }
+}
+
+module.exports = DataTestCase;

package/project/client/data/data-test-case/data-test-data-iteration.js

@@ -0,0 +1,54 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataTestDataIteration extends DataTableKeyValue {
+  constructor(phase, type, key, value, description) {
+    super([
+      ['phase', (rowData) => {return 'exec'}],
+      ['type', (rowData) => {
+        if(rowData.phase === 'pre') {
+          return 'cond';
+        }
+        else if(rowData.phase === 'exec') {
+          return 'orig';
+        }
+        else if(rowData.phase === 'post') {
+          return 'cond';
+        }
+      }]
+    ],
+    [
+      ['phase', (rowData) => {
+        return this.getAllowedPhase(rowData);
+      }],
+      ['type', (rowData) => {
+        return this.getAllowedType(rowData);
+      }]
+    ]);
+    this.phase = phase;
+    this.type = type;
+    this.key = key;
+    this.value = value;
+    this.description = description;
+  }
+       
+  getAllowedPhase(rowData) {
+    switch(rowData.phase) {
+      case 'pre':
+      case 'exec':
+      case 'post':
+        return DataTableKeyValue.ALLOWED_OK;
+      default:
+        return DataTableKeyValue.ALLOWED_NOK_VALUE;
+    }
+  }
+    
+  getAllowedType(rowData) {
+    return DataTableKeyValue.ALLOWED_OK;
+  }
+}
+
+module.exports = DataTestDataIteration;

package/project/client/data/data-test-case/data-test-data-test-case.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataTestDataTestCase extends DataTableKeyValue {
+  constructor(key, value, description) {
+    super();
+    this.key = key;
+    this.value = value;
+    this.description = description;
+  }
+}
+
+module.exports = DataTestDataTestCase;

package/project/client/data/data-test-case/data-verification-test-case.js

@@ -0,0 +1,24 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataVerificationTestCase extends DataTableKeyValue {
+  constructor(key, value, operation, type, description) {
+    super([
+      ['type', (rowData) => {return 'string'}],
+      ['operation', (rowData) => {return '==='}]
+    ],
+    [
+      []
+    ]);
+    this.key = key;
+    this.value = value;
+    this.operation = operation;
+    this.type = type;
+    this.description = description;
+  }
+}
+
+module.exports = DataVerificationTestCase;

package/project/client/data/data-test-data/data-test-data-environment-global.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataTestDataEnvironmentGlobal extends DataTableKeyValue {
+  constructor(name, sut, sutInstance, value, description) {
+    super();
+    this.name = name;
+    this.sut = sut;
+    this.sutInstance = sutInstance;
+    this.value = value;
+    this.description = description;
+  }
+}
+
+module.exports = DataTestDataEnvironmentGlobal;

package/project/client/data/data-test-data/data-test-data-environment-local.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataTestDataEnvironmentLocal extends DataTableKeyValue {
+  constructor(name, sut, sutInstance, value, description) {
+    super();
+    this.name = name;
+    this.sut = sut;
+    this.sutInstance = sutInstance;
+    this.value = value;
+    this.description = description;
+  }
+}
+
+module.exports = DataTestDataEnvironmentLocal;

package/project/client/data/data-test-data/data-test-data-environment-static.js

@@ -0,0 +1,16 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataTestDataEnvironmentStatic extends DataTableKeyValue {
+  constructor(name, value, description) {
+    super();
+    this.name = name;
+    this.value = value;
+    this.description = description;
+  }
+}
+
+module.exports = DataTestDataEnvironmentStatic;

package/project/client/data/data-test-data/data-test-data-general-global.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataTestDataGeneralGlobal extends DataTableKeyValue {
+  constructor(name, sut, sutInstance, value, description) {
+    super();
+    this.name = name;
+    this.sut = sut;
+    this.sutInstance = sutInstance;
+    this.value = value;
+    this.description = description;
+  }
+}
+
+module.exports = DataTestDataGeneralGlobal;

package/project/client/data/data-test-data/data-test-data-general-local.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataTestDataGeneralLocal extends DataTableKeyValue {
+  constructor(name, sut, sutInstance, value, description) {
+    super();
+    this.name = name;
+    this.sut = sut;
+    this.sutInstance = sutInstance;
+    this.value = value;
+    this.description = description;
+  }
+}
+
+module.exports = DataTestDataGeneralLocal;

package/project/client/data/data-test-data/data-test-data-output-global.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataTestDataOutputGlobal extends DataTableKeyValue {
+  constructor(name, sut, sutInstance, value, description) {
+    super();
+    this.name = name;
+    this.sut = sut;
+    this.sutInstance = sutInstance;
+    this.value = value;
+    this.description = description;
+  }
+}
+
+module.exports = DataTestDataOutputGlobal;

package/project/client/data/data-test-data/data-test-data-output-local.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+const DataTableKeyValue = require('../data-table-key-value');
+
+
+class DataTestDataOutputLocal extends DataTableKeyValue {
+  constructor(name, sut, sutInstance, value, description) {
+    super();
+    this.name = name;
+    this.sut = sut;
+    this.sutInstance = sutInstance;
+    this.value = value;
+    this.description = description;
+  }
+}
+
+module.exports = DataTestDataOutputLocal;