@aj-shadow/actorjs-app 0.0.0-aj-beta.221

package/project/server/plugin-data/test-case/plugin_data_TestCaseDelete.js

@@ -0,0 +1,20 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class TestCaseDelete extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.DELETE);
+  }
+  
+  onRequest(tcs) {
+    tcs.forEach((tc) => { 
+      this.asynchRmdirResponse(ActorPathData.getTestCaseFolder(tc.repo, tc.sut, tc.fut, tc.tc), true);
+    });
+  }
+}
+
+module.exports = TestCaseDelete;

package/project/server/plugin-data/test-case/plugin_data_TestCaseExecutionStart.js

@@ -0,0 +1,73 @@
+
+'use strict';
+
+const TestCaseLoader = require('z-abs-funclayer-engine-server/server/engine/test-case-loader');
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBase = require('z-abs-corelayer-server/server/plugin-base');
+const Logger = require('z-abs-corelayer-server/server/log/logger');
+const Fs = require('fs');
+
+
+class TestCaseExecutionStart extends PluginBase {
+  constructor() {
+    super(PluginBase.GET);
+    this.testCase = null;
+  }
+  
+  onRequest(repoName, sutName, futName, tcName, sutInstance, stagedNodes, config) {
+    TestCaseLoader.load(repoName, sutName, futName, tcName, sutInstance, stagedNodes, false, config, this.cbMessage, (err, testCase) => {
+      if(err) {
+        if('N/A' === err.message) {
+          return this.responsePartError('N/A');
+        }
+        else {
+          const errorLog = `Could not find the Test Case: '${ActorPathData.getTestCaseFile(repoName, sutName, futName, tcName)}'`;
+          LOG_ERROR(Logger.ERROR.CATCH, errorLog, err);
+          return this.responsePartError(errorLog);
+        }
+      }
+      else {
+        this.testCase = testCase;
+        process.nextTick((testCase) => {
+          testCase.executionContext.initTestCase(testCase);
+          testCase.run((done) => {
+            testCase.executionContext.exitTestCase(testCase, done);
+          });
+        }, testCase);
+        return this.responsePartSuccess();
+      }
+    });
+  }
+  
+  onMessageToClient(msg, dataBuffers, cbMessage) {
+    if(AppProtocolConst.TEST_CASE_STOPPED === msg.msgId && msg.last) {
+      this.clearSession(() => {
+        cbMessage(msg, dataBuffers);
+      });
+    }
+    else {
+      cbMessage(msg, dataBuffers);
+    }
+  }
+  
+  onMessageFromClient(msg) {
+    if(AppProtocolConst.TEST_CASE_STOP === msg.msgId) {
+      if(null !== this.testCase) {
+        this.testCase.stop(() => {});
+      }
+    }
+  }
+  
+  onClose(done) {
+    if(null !== this.testCase) {
+      this.testCase.stop(done);
+    }
+    else {
+      done();
+    }
+  }
+}
+
+
+module.exports = TestCaseExecutionStart;

package/project/server/plugin-data/test-case/plugin_data_TestCaseGet.js

@@ -0,0 +1,118 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Fs = require('fs');
+const Path = require('path');
+
+
+class TestCaseGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest(repoName, sutName, futName, tcName) {
+    if(tcName) {
+      this.getTestCase(repoName, sutName, futName, tcName, (data, err) => {
+        if(err) {
+          return this.responsePartError('Could not get the Test Case from file.');
+        }
+        else {
+          return this.responsePartSuccess({
+            testCase: data
+          });
+        }
+      });
+    }
+    else {
+      let responseDone = false;
+      this.getTestCases(repoName, sutName, futName, (data, err) => {
+        if(!responseDone) {
+          responseDone = true;
+          if(err) {
+            return this.responsePartError('Could not get the Test Cases.');
+          }
+          data.sort((a, b) => {
+            if(a.name < b.name) {
+              return -1;
+            }
+            else if(b.name < a.name) {
+              return 1;
+            }
+            else {
+              return 0;
+            }
+          });
+          return this.responsePartSuccess({
+            testCases: data
+          });
+        }
+      });
+    }
+  }
+  
+  getTestCase(repoName, sutName, futName, tcName, done) {
+    Fs.readFile(ActorPathData.getTestCaseFile(repoName, sutName, futName, tcName), (err, data) => {
+      if(err) {
+        return done(undefined, err);
+      }
+      else {
+        return done(JSON.parse(data));
+      }
+    });
+  }
+  
+  getTestCases(repoName, sutName, futName, done, previusError=false) {
+    const testCases = [];
+    const dir = ActorPathData.getTestCasesFolder(repoName, sutName, futName);
+    Fs.readdir(dir, (err, files) => {
+      if(err) {
+        if(!previusError && 'ENOENT' === err.code) {
+          return this.asynchMkdir(dir, (mkdirErr) => {
+            if(mkdirErr) {
+              return done(testCases, mkdirErr);
+            }
+            this.getTestCases(repoName, sutName, futName, done, true);
+          });
+        }
+        return done(testCases, err);
+      }
+      let pendings = files.length;
+      if(0 === pendings) {
+        return done(testCases);
+      }
+      for(let i = 0; i < files.length; ++i) {
+        const file = files[i];
+        const resolvedDir = Path.resolve(dir, file);      
+        Fs.stat(resolvedDir, (err, stat) => {
+          if(err) {
+            return done(testCases, err);
+          }
+          if(stat && stat.isDirectory()) {
+            const prefix = `Tc`;//${sutName}${futName}
+            if(file.startsWith(prefix) && file.length > prefix.length) {
+              Fs.readFile(ActorPathData.getTestCaseFile(repoName, sutName, futName, file.substr(prefix.length)), (err, data) => {
+                if(err) {
+                  return done(testCases, err);
+                }	  
+                testCases.push(JSON.parse(data));
+                if(0 === --pendings) {
+                  return done(testCases);
+                }
+              });
+            }
+            else if(0 === --pendings) {
+              return done(testCases);
+            }
+          }
+          else if(0 === --pendings) {
+            return done(testCases);
+          }
+        });
+      }
+    });
+  }
+}
+
+module.exports = TestCaseGet;

package/project/server/plugin-data/test-case/plugin_data_TestCaseRecentDelete.js

@@ -0,0 +1,57 @@
+
+'use strict';
+
+const ActorPathGenerated = require('z-abs-corelayer-server/server/path/actor-path-generated');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Fs = require('fs');
+const Path = require('path');
+
+
+class TestCaseRecentDelete extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest(repo, suts, futs, tcs) {
+    this.writeLock(ActorPathGenerated.getTestCasesRecentFile(), (unlock) => {
+      Fs.readFile(ActorPathGenerated.getTestCasesRecentFile(), (err, data) => {
+        if(err) {
+          unlock();
+          return this.responsePartError(`Could not delete the TestCases Recent Files: ' ${ActorPathGenerated.getTestCasesRecentFile()} '.`);
+        }
+        const parsedData = JSON.parse(data);
+        const filteredData = this.deleteRecentFiles(parsedData, repo, suts, futs, tcs);
+        Fs.writeFile(ActorPathGenerated.getTestCasesRecentFile(), JSON.stringify(filteredData, null, 2), (err) => {
+          unlock();
+          if(err) {
+            return this.responsePartError(`Could not delete the TestCases Receant Files: ' ${ActorPathGenerated.getTestCasesRecentFile()} '.`);
+          }
+          return this.responsePartSuccess();
+        });
+      });
+    });
+  }
+  
+  deleteRecentFiles(recentFiles, repo, suts, futs, tcs) {
+    if(null !== tcs) {
+      for(let j = 0; j < tcs.length; ++j) {
+        recentFiles = recentFiles.filter((recentFile) => {
+          return !(tcs[j].repo === recentFile.repo && tcs[j].sut === recentFile.sut && tcs[j].fut === recentFile.fut && tcs[j].tc === recentFile.tc);
+        });
+      }
+    }
+    else if(null !== futs) {
+      recentFiles = recentFiles.filter((recentFile) => {
+        return !(repo === recentFile.repo && suts === recentFile.sut && futs === recentFile.fut);
+      });
+    }
+    else if(null !== suts) {
+      recentFiles = recentFiles.filter((recentFile) => {
+        return !(repo === recentFile.repo && suts === recentFile.sut);
+      });
+    }
+    return recentFiles;
+  }
+}
+
+module.exports = TestCaseRecentDelete;

package/project/server/plugin-data/test-case/plugin_data_TestCaseRecentGet.js

@@ -0,0 +1,20 @@
+
+'use strict';
+
+const ActorPathGenerated = require('z-abs-corelayer-server/server/path/actor-path-generated');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Fs = require('fs');
+const Path = require('path');
+
+
+class TestCaseRecentGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    this.asynchReadFileResponse(ActorPathGenerated.getTestCasesRecentFile());
+  }
+}
+
+module.exports = TestCaseRecentGet;

package/project/server/plugin-data/test-case/plugin_data_TestCaseRecentUpdate.js

@@ -0,0 +1,62 @@
+
+'use strict';
+
+const ActorPathGenerated = require('z-abs-corelayer-server/server/path/actor-path-generated');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Fs = require('fs');
+
+
+class TestCaseRecentUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.ADD);
+    this.maxTestCases = 10;
+  }
+  
+  onRequest(repoName, sutName, futName, tcName) {
+    this.writeLock(ActorPathGenerated.getTestCasesRecentFile(), (unlock) => {
+      Fs.readFile(ActorPathGenerated.getTestCasesRecentFile(), (err, data) => {
+        if(err) {
+          unlock();
+          return this.responsePartError(`Could not get the TestCases Recent File: ' ${ActorPathGenerated.getTestCasesRecentFile()} '.`);
+        }
+        const parsedData = this._safeJsonParse(data, (e) => {
+          return this.responsePartError(`Could not JSON.parse the TestCases Recent File: ' ${ActorPathGenerated.getTestCasesRecentFile()} '.`);
+        });
+        Fs.writeFile(ActorPathGenerated.getTestCasesRecentFile(), JSON.stringify(this.updateRecentFiles(parsedData, repoName, sutName, futName, tcName), null, 2), (err) => {
+          unlock();
+          if(err) {
+            return this.responsePartError(`Could not update the TestCases Recent File: ' ${ActorPathGenerated.getTestCasesRecentFile()} '.`);
+          }
+          return this.responsePartSuccess();
+        });
+      });
+    });
+  }
+  
+  updateRecentFiles(recentFiles, repoName, sutName, futName, tcName) {
+    for(let i = 0; i < recentFiles.length; ++i) {
+      if(sutName === recentFiles[i].sut && futName === recentFiles[i].fut && tcName === recentFiles[i].tc) {
+        recentFiles.splice(i, 1);
+        recentFiles.unshift({
+          repo: repoName,
+          sut: sutName,
+          fut: futName,
+          tc: tcName
+        });
+        return recentFiles;
+      }
+    }
+    if(this.maxTestCases < recentFiles.length) {
+      recentFiles.pop();
+    }
+    recentFiles.unshift({
+      repo: repoName,
+      sut: sutName,
+      fut: futName,
+      tc: tcName
+    });
+    return recentFiles;
+  }
+}
+
+module.exports = TestCaseRecentUpdate;

package/project/server/plugin-data/test-case/plugin_data_TestCaseRename.js

@@ -0,0 +1,43 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Path = require('path');
+
+
+class TestCaseRename extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.ADD);
+  }
+  
+  onRequest(repo, sut, fut, currentTcName, newTcName, description) {
+    const currentFolder = ActorPathData.getTestCaseFolder(repo, sut, fut, currentTcName);
+    const newFolder = ActorPathData.getTestCaseFolder(repo, sut, fut, newTcName);
+    const newFile = newFolder + Path.sep + ActorPathData.getTestCaseFileName(newTcName);
+    this.asynchRename(currentFolder, newFolder, (err) => {
+      if(!err) {
+        this.asynchRename(newFolder + Path.sep + ActorPathData.getTestCaseFileName(currentTcName), newFile, (err) => {
+          if(!err) {
+            this.asynchReadFile(newFile, (err, data) => {
+              if(err) {
+                consle.log(err);
+              }
+              data.name = newTcName;
+              data.description = description;
+              this.asynchWriteFileResponse(newFile, data);
+            });
+          }
+          else {
+            this.responsePartError(`Could rename Test Case '${currentTcName}' to '${newTcName}'. Files might be corrupt. You might have to use 'git restore'`);
+          }
+        });
+      }
+      else {
+        this.responsePartError(`Could rename Test Case '${currentTcName}' to '${newTcName}'.`);
+      }
+    });
+  }
+}
+
+module.exports = TestCaseRename;

package/project/server/plugin-data/test-case/plugin_data_TestCaseSpecificationUpdate.js

@@ -0,0 +1,21 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class TestCaseSpecificationUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(repoName, sutName, futName, tcName, testCase, specification) {
+    if(undefined !== specification) {
+      testCase.specification = specification;
+    }
+    this.asynchWriteFileResponse(ActorPathData.getTestCaseFile(repoName, sutName, futName, tcName), testCase);
+  }
+}
+
+module.exports = TestCaseSpecificationUpdate;

package/project/server/plugin-data/test-case/plugin_data_TestCaseStacksGet.js

@@ -0,0 +1,54 @@
+
+'use strict';
+
+const StackComponentsFactory = require('z-abs-funclayer-stack-server/server/factory/stack-components-factory');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class TestCaseStacksGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    const templatesMap = [];
+    StackComponentsFactory.getStacks((stacks) => {
+      stacks.forEach((stack) => {
+        const testCaseTemplateFactory = StackComponentsFactory.createTemplatesTestCases(stack.name);
+        if(testCaseTemplateFactory) {
+          try {
+            const templatesTypeMap = [];
+            const templates = new testCaseTemplateFactory().templates;
+            if(templates) {
+              templates.forEach((template) => {
+                templatesTypeMap.push([
+                  template.displayName,
+                  {
+                    displayName: template.displayName,
+                    regressionFriendly: template.regressionFriendly,
+                    template: template.template,
+                    testDataViews: template.testDataViews,
+                    markupNodes: template.markupNodes,
+                    markup: template.markup
+                  }
+                ]);
+              });
+              if(0 !== templatesTypeMap.length) {
+                templatesMap.push([
+                  stack.name,
+                  templatesTypeMap
+                ]);
+              }
+            }
+          }
+          catch(err) {
+            ddb.error(`Failing to load stack '${stack.name}' for Test Case Templates.`, err)
+          }
+        } 
+      });
+      this.expectAsynchResponseSuccess(templatesMap);     
+    });
+  }
+}
+
+module.exports = TestCaseStacksGet;

package/project/server/plugin-data/test-case/plugin_data_TestCaseUpdate.js

@@ -0,0 +1,42 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Fs = require('fs');
+
+
+class TestCaseUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.ADD);
+  }
+  
+  onRequest(repoName, sutName, futName, tcName, description, tc) {
+    const responsePart = this.verifyInput(tc);
+    if(true !== responsePart) {
+      return responsePart;
+    }
+    Fs.writeFile(ActorPathData.getTestCaseFile(repoName, sutName, futName, tcName), JSON.stringify(tc, null, 2), (err) => {
+      if(err) {
+        return this.responsePartError(`Could not update the TestCase File: ' ${ActorPathData.getTestCaseFile(repoName, sutName, futName, tcName)} '.`);
+      }
+      else {
+        return this.responsePartSuccess();
+      }
+    });
+  }
+  
+  verifyInput(testCase) {
+    const name = testCase.name;
+    if(0 === name.length) {
+      return this.responsePartError(`The Test Case name: '' must not be empty.`);
+    }
+    const first = name.charAt(0);
+    if(first === first.toLowerCase() || first !== first.toUpperCase()) {
+      return this.responsePartError(`A Test Case name must start with uppercase, name: '${name}'.`);
+    }
+    return true;
+  }
+}
+
+module.exports = TestCaseUpdate;

package/project/server/plugin-data/test-data/plugin_data_TestDataEnvironmentGet.js

@@ -0,0 +1,72 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class TestDataEnvironmentGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+    this.statics = [
+      {
+        name: 'undefined',
+        value: undefined,
+        description: 'The value undefined. Cannot be part of a formatting.'
+      },
+      {
+        name: 'null',
+        value: null,
+        description: 'The value null. Cannot be part of a formatting.'
+      },
+      {
+        name: 'pipe',
+        value: '|',
+        description: `The value '|', pipe.`
+      },
+      {
+        name: 'space',
+        value: ' ',
+        description: `The value ' ', space.`
+      },
+      {
+        name: 'preActorNames',
+        value: undefined,
+        description: 'An Array containing the names of the Actors in the current Test Case´s pre phase.'
+      },
+      {
+        name: 'preActorInstanceIndices',
+        value: undefined,
+        description: 'An Array containing the instance indices of the Actors in the current Test Case´s pre phase.'
+      },
+      {
+        name: 'execActorNames',
+        value: undefined,
+        description: 'An Array containing the names of the Actors in the current Test Case´s exec phase.'
+      },
+      {
+        name: 'execActorInstanceIndices',
+        value: undefined,
+        description: 'An Array containing the instance indices of the Actors in the current Test Case´s exec phase.'
+      },
+      {
+        name: 'postActorNames',
+        value: undefined,
+        description: 'An Array containing the names of the Actors in the current Test Case´s post phase.'
+      },
+      {
+        name: 'postActorInstanceIndices',
+        value: undefined,
+        description: 'An Array containing the instance indices of the Actors in the current Test Case´s post phase.'
+      }
+    ];
+  }
+  
+  onRequest() {
+    this.asynchReadFileResponse(ActorPathData.getTestDataEnvironmentGlobalFile());
+    this.asynchReadFileResponse(ActorPathData.getTestDataEnvironmentLocalFile());
+    this.expectAsynchResponseSuccess(this.statics);
+  }
+}
+
+module.exports = TestDataEnvironmentGet;

package/project/server/plugin-data/test-data/plugin_data_TestDataEnvironmentUpdate.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class TestDataEnvironmentUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(globals, locals) {
+    this.asynchWriteFileResponse(ActorPathData.getTestDataEnvironmentGlobalFile(), globals, false);
+    this.asynchWriteFileResponse(ActorPathData.getTestDataEnvironmentLocalFile(), locals, false);
+  }
+}
+
+module.exports = TestDataEnvironmentUpdate;

package/project/server/plugin-data/test-data/plugin_data_TestDataGeneralGet.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class TestDataGeneralGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    this.asynchReadFileResponse(ActorPathData.getTestDataGeneralGlobalFile());
+    this.asynchReadFileResponse(ActorPathData.getTestDataGeneralLocalFile());
+  }
+}
+
+module.exports = TestDataGeneralGet;

package/project/server/plugin-data/test-data/plugin_data_TestDataGeneralUpdate.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class TestDataGeneralUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(globals, locals) {
+    this.asynchWriteFileResponse(ActorPathData.getTestDataGeneralGlobalFile(), globals, false);
+    this.asynchWriteFileResponse(ActorPathData.getTestDataGeneralLocalFile(), locals, false);
+  }
+}
+
+module.exports = TestDataGeneralUpdate;

package/project/server/plugin-data/test-data/plugin_data_TestDataOutputGet.js

@@ -0,0 +1,19 @@
+
+'use strict';
+
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class TestDataOutputGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest() {
+    this.asynchReadFileResponse(ActorPathData.getTestDataOutputGlobalFile());
+    this.asynchReadFileResponse(ActorPathData.getTestDataOutputLocalFile());
+  }
+}
+
+module.exports = TestDataOutputGet;