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

package/project/server/plugin-data/system-under-test/plugin_data_SystemUnderTestUpdate.js

@@ -0,0 +1,24 @@
+
+'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 SystemUnderTestUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(suts) {
+    this.updateSystemsUnderTest(suts);
+  }
+  
+  updateSystemsUnderTest(suts) {
+    suts.forEach((sut) => {
+      this.asynchWriteFileResponse(ActorPathData.getSystemUnderTestFile(sut.repo, sut.name), sut, false);
+    });
+  }
+}
+
+module.exports = SystemUnderTestUpdate;

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

@@ -0,0 +1,39 @@
+
+'use strict';
+
+
+class Debug {
+  static async _getPossibleBreakpoints(client, dbugger, breakpoint, breakpoints) {
+    const parameters = dbugger.getScriptParametersFromUrl(breakpoint.url);
+    if(parameters) {
+      const scriptId = parameters.scriptId;
+      try {
+        const result = await client.Debugger.getPossibleBreakpoints({
+          start: {
+            scriptId: scriptId,
+            lineNumber: breakpoint.lineNumber,
+            columnNumber: 0
+          },
+          end: {
+            scriptId: scriptId,
+            lineNumber: breakpoint.lineNumber + 1,
+            columnNumber: 0
+          }
+        });
+        const locations = result.locations;
+        let columnNumber = 0 < locations.length ? locations[0].columnNumber : 0;
+        for(let i = 0; i < locations.length; ++i) {
+          if('call' === locations[i].type || 'return' === locations[i].type || undefined === locations[i].type) {
+            columnNumber = locations[i].columnNumber;
+            break;
+          }
+        }
+        breakpoint.columnNumber = columnNumber;
+      }
+      catch(e) {}
+    }
+  }
+}
+
+
+module.exports = Debug;

package/project/server/plugin-data/test-case/debugger-api.js

@@ -0,0 +1,398 @@
+
+'use strict';
+
+const ActorPathDist = require('z-abs-corelayer-server/server/path/actor-path-dist');
+const Path = require('path');
+
+
+class DebuggerApi {
+  constructor(_debugger) {
+    this.debugger = _debugger;
+    this.breakpoints = [];
+    this.runBreakpoints = [];
+    this.scriptCacheScriptId = new Map();
+    this.scriptCacheUrl = new Map();
+    this.pause = false;
+    this.resume = true;
+    this.stepOver = false;
+    this.stepOverBreakpoints = [];
+    this.stepInto = false;
+    this.stepOut = false;
+    this.stepOutBreakpoints = [];
+    this.previousLocation = {};
+    this.currentStack = [];
+    this.previousStack = [];
+  }
+  
+  async onDebuggerEnabled() {
+    try {
+      const breakpoints = this._getBreakpoints();
+      for(let i = 0; i < breakpoints.length; ++i) {
+        const breakpoint = breakpoints[i];
+        if(breakpoint.pauseOnBreak) {
+          await this.getPossibleBreakpoints(breakpoint);
+          const result = await this.debugger.debuggerSetBreakpointByUrl(breakpoint);
+          breakpoint.breakpointId = result.breakpointId;
+        }
+      }
+      if(this.breakOnEnterRun || this.breakOnLeaveRun) {
+        for(let i = 0; i < this.runBreakpoints.length; ++i) {
+          const runBreakpoint = this.runBreakpoints[i];
+          if(!this._findbreakpointInBreakpoints(runBreakpoint)) {
+            await this.getPossibleBreakpoints(runBreakpoint);
+            const result = await this.debugger.debuggerSetBreakpointByUrl(runBreakpoint);
+            this._setRunBreakpoint(runBreakpoint);
+          }
+        }
+      }
+    }
+    catch(err) {
+      ddb.error('FAILURE[_enable]:', err);
+    };
+  }
+  
+  async onDebuggerPaused(parameters) {
+    const stackData = await this._pausedCollectStack(parameters);
+    this.previousStack = this.currentStack;
+    this.currentStack = stackData;
+    if(this.resume) {
+      this.resume = false;
+    }
+    else if(this.stepOver) {
+      return await this._pausedStepOver(stackData, parameters.hitBreakpoints);
+    }
+    else if(this.stepInto) {
+      this.stepInto = false;
+    }
+    else if(this.stepOut) {
+      return await this._pausedStepOut(stackData, parameters.hitBreakpoints);
+    }
+    else if(this.pause) {
+      this.pause = false;
+    }
+    else {
+      return;
+    }
+    return await this._getScript(stackData);
+  }
+  
+  async onDebuggerContinue() {
+    this.resume = true;
+    await this.debugger.debuggerResume();
+  }
+  
+  async onDebuggerStepOver() {
+    this.stepOverBreakpoints = await this._getPossibleBreakpointsStepOver();
+    this.stepOver = true;
+    await this.debugger.debuggerStepOver();
+  }
+  
+  async onDebuggerStepInto() {
+    this.stepInto = true;
+    await this.debugger.debuggerStepInto();
+  }
+  
+  async onDebuggerStepOut() {
+    this.stepOutBreakpoints = await this._getPossibleBreakpointsStepOut();
+    this.stepOut = true;
+    await this.debugger.debuggerStepOut();
+  }
+  
+  async onDebuggerPause() {
+    this.pause = true;
+    await this.debugger.debuggerPause();
+  }
+  
+  async runtimeGetProperties(parameters) {
+    return await this.debugger.runtimeGetProperties(parameters);
+  }
+  
+  async getPossibleBreakpoints(breakpoint) {
+    const parameters = this._getScriptParametersFromUrl(breakpoint.url);
+    if(parameters) {
+      const scriptId = parameters.scriptId;
+      try {
+        const breakpoints = await this.debugger.debuggerGetPossibleBreakpoints({
+          start: {
+            scriptId: scriptId,
+            lineNumber: breakpoint.lineNumber,
+            columnNumber: 0
+          },
+          send: {
+            scriptId: scriptId,
+            lineNumber: breakpoint.lineNumber + 1,
+            columnNumber: 0
+          }
+        });
+        const locations = breakpoints.locations;
+        let columnNumber = 0 < locations.length ? locations[0].columnNumber : 0;
+        for(let i = 0; i < locations.length; ++i) {
+          if('call' === locations[i].type || 'return' === locations[i].type || undefined === locations[i].type) {
+            columnNumber = locations[i].columnNumber;
+            break;
+          }
+        }
+        breakpoint.columnNumber = columnNumber;
+      }
+      catch(err) {
+        console.log('getPossibleBreakpoints:', scriptId, breakpoint.lineNumber, err);
+      }
+    }
+  }
+  
+  async _pausedCollectStack(parameters) {
+    const stack = [];
+    try {
+      for(let i = 0; i < parameters.callFrames.length; ++i) {
+        const callFrame = parameters.callFrames[i];
+        const url = this._getScriptParameters(callFrame.location.scriptId).url;
+        let thisMembers = [];
+        if(callFrame.this && callFrame.this.objectId) {
+          thisMembers = await this.runtimeGetProperties({objectId: callFrame.this.objectId});
+        }
+        const scopes = [];
+        for(let j = 0; j < callFrame.scopeChain.length; ++j) {
+          const scope = callFrame.scopeChain[j];
+          if(scope.object && scope.object.objectId) {
+            const scopeMembers = await this.runtimeGetProperties({objectId: scope.object.objectId});
+            scopes.push({
+              type: scope.type,
+              name: scope.name,
+              object: scopeMembers ? scopeMembers.result : null,
+              startLocation: scope.startLocation,
+              endLocation: scope.endLocation
+            });
+          }
+        }
+        stack.push({
+          callFrameId: callFrame.callFrameId,
+          functionName: callFrame.functionName,
+          objectName: callFrame.this.className,
+          location: callFrame.location,
+          scriptName: Path.parse(url).base,
+          url: url,
+          this: callFrame.this,
+          scopes: scopes,
+          thisMembers
+        });
+      }
+    }
+    catch(err) {
+      console.log('_pausedCollectStack:', err);
+    }
+    return {
+      stack
+    };
+  }
+  
+  async _getScriptFromId(scriptId) {
+    const source = await this.debugger.debuggerGetScriptSource(scriptId);
+    try {
+      return {
+        scriptId: scriptId,
+        script: source.scriptSource
+      };
+    }
+    catch(err) {
+      console.log('_getScriptFromId:', err);
+    }
+  }
+  
+  async _getScript(stack) {
+    const scriptId = stack.stack[0].location.scriptId;
+    try {
+      const source = await this.debugger.debuggerGetScriptSource(scriptId);
+      return {
+        stack: stack.stack,
+        scriptId: scriptId,
+        script: source.scriptSource
+      };
+    }
+    catch(err) {
+      console.log('_getScript:', err);
+    }
+  }
+  
+  async _getPossibleBreakpointsStepOver() {
+    const results = [];
+    for(let i = 0; i < this.currentStack.stack.length; ++i) {
+      const stack = this.currentStack.stack[i];
+      for(let i = 0; i < stack.scopes.length; ++i) {
+        const scope = stack.scopes[i];
+        if(scope.startLocation) {
+          try {
+            const result = await this.debugger.debuggerGetPossibleBreakpoints({
+              start: scope.startLocation,
+              stop: scope.endLocation
+            });
+            const res = {
+              scriptName: stack.scriptName,
+              location: stack.location,
+              locations: result.locations
+            };
+            results.push(res);
+          }
+          catch(err) {
+            console.log('_getPossibleBreakpointsStepOver:', err);
+          }
+        }
+      }
+    }
+    return results;
+  }
+  
+  async _pausedStepOver(stackData, hitBreakpoints) {
+    let found = null;
+    if(0 !== hitBreakpoints.length) {
+      this.stepOver = false;
+      return await this._getScript(stackData);
+    }
+    else if(0 !== this.stepOverBreakpoints.length) {
+      for(let i = 0; i < this.stepOverBreakpoints.length; ++i) {
+        const bp = this.stepOverBreakpoints[i];
+        for(let j = 0; j < bp.locations.length; ++j) {
+          const b = bp.locations[j];
+          if(stackData.stack[0].location.scriptId === b.scriptId && stackData.stack[0].location.lineNumber === b.lineNumber && stackData.stack[0].location.columnNumber === b.columnNumber) {
+            found = b;
+            break;
+          }
+        }
+      }
+      if(found) {
+        this.stepOver = false;
+        this.previousLocation = found;
+        return await this._getScript(stackData);
+      }
+      else {
+        if('return' === this.previousLocation.type) {
+          this.stepOver = false;
+          return await this._getScript(stackData);
+        }
+        if('call' === this.previousLocation.type) {
+          await this.debugger.debuggerStepOver();
+          return;
+        }
+        else {
+          await this.debugger.debuggerStepOver();
+          return;
+        }
+      }
+    }
+  }
+  
+  async _getPossibleBreakpointsStepOut() {
+    const results = [];
+    for(let i = 1; i < this.currentStack.stack.length; ++i) {
+      const stack = this.currentStack.stack[i];
+      const scope = stack.scopes[0];
+      if(scope.startLocation) {
+        try {
+          const result = await this.getPossibleBreakpoints({
+            start: scope.startLocation,
+            end: scope.endLocation
+          });
+          const res = {
+            scriptName: stack.scriptName,
+            location: stack.location,
+            locations: result.locations
+          };
+          results.push(res);
+        }
+        catch(err) {
+          console.log('_getPossibleBreakpointsStepOut:', err);
+        }
+      }
+    }
+    return results;
+  }
+  
+  static calculateBreakpointUrl(sut, fut, tc, breakpoint) {
+    let url = `${ActorPathDist.getActorDistActorsPath()}/${breakpoint.name}`;
+    if(url.startsWith('/')) {
+      url = `file://${Path.normalize(url)}`;
+    }
+    else {
+      url = `file:///${Path.normalize(url)}`;
+    }
+    url = url.replace(/\\/g, '/');
+    return url;
+  }
+  
+  calculateBreakpointUrl(sut, fut, tc, breakpoint) {
+    return DebuggerApi.calculateBreakpointUrl(sut, fut, tc, breakpoint);
+  }
+  
+  _setBreakpoints(breakpoints) {
+    this.breakpoints = breakpoints;
+  }
+  
+  _getBreakpoints() {
+    return this.breakpoints;
+  }
+  
+  _setBreakpoint(breakpoint) {
+    const index = this._findIndexBreakpoint(breakpoint);
+    if(-1 === index) {
+      this.breakpoints.push(breakpoint);
+    }
+    else {
+      this.breakpoints[index] = breakpoint;
+    }
+  }
+  
+  _getBreakpoint(breakpoint) {
+    const index = this._findIndexBreakpoint(breakpoint);
+    if(-1 !== index) {
+      return this.breakpoints[index];
+    }
+  }
+  
+  _removeBreakpoint(breakpoint) {
+    const index = this._findIndexBreakpoint(breakpoint);
+    if(-1 !== index) {
+      this.breakpoints.splice(index, 1);
+    }
+  }
+  
+  setRunBreakpoint(breakpoint) {
+    this.runBreakpoints.push(breakpoint);
+  }
+  
+  _clearRunBreakpoints() {
+    this.runBreakpoints = [];
+  }
+  
+  _scriptParsed(parameters) {
+    this.scriptCacheScriptId.set(parameters.scriptId, parameters);
+    this.scriptCacheUrl.set(parameters.url, parameters);
+  }
+  
+  _getScriptParameters(scriptId) {
+   return this.scriptCacheScriptId.get(scriptId);
+  }
+  
+  _getScriptParametersFromUrl(url) {
+    return this.scriptCacheUrl.get(url);
+  }
+  
+  _findIndexBreakpoint(breakpoint) {
+    return this.breakpoints.findIndex((foundBreakpoint) => {
+      return foundBreakpoint.name === breakpoint.name && foundBreakpoint.lineNumber === breakpoint.lineNumber;
+    });
+  }
+  
+  _findbreakpointInBreakpoints(breakpoint) {
+    return !!this.breakpoints.find((serchBreakpoint) => {
+      return serchBreakpoint.lineNumber === breakpoint.lineNumber;
+    });
+  }
+  
+  _findbreakpointInRunBreakpoints(breakpoint) {
+    return !!this.runBreakpoints.find((serchBreakpoint) => {
+      return serchBreakpoint.lineNumber === breakpoint.lineNumber;
+    });
+  }
+}
+
+
+module.exports = DebuggerApi;

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

@@ -0,0 +1,129 @@
+
+'use strict';
+
+
+class Debugger {
+  constructor(sessionData, cbObject) {
+    this.target = sessionData.data;
+    this.cbObject = cbObject;
+    this.idCounter = 0;
+    this.ws = null;
+    this.pending = new Map();
+  }
+  
+  async connect(done) {
+    try {
+      this.ws = new WebSocket(this.target);
+      this.ws.onopen = async () => {
+        await this.consoleDisable();
+        done();
+      };
+      this.ws.onclose = (event) => {
+        //console.log(`WebSocket closed. Code: ${event.code}, Reason: ${event.reason}`);
+        this.ws = null;
+        this.pending.clear();
+      };
+      this.ws.onmessage = this.onMessage.bind(this);
+    }
+    catch(err) {
+      done(err);
+    }
+  }
+  
+  close() {
+    //console.log('close');
+    this.ws.close(1000, 'Debugger session complete');
+    // TO DO ASYNC
+  }
+  
+  async consoleDisable() {
+    await this.send('Console.disable');
+  }
+  
+  async debuggerEnable() {
+    await this.send('Debugger.enable');
+  }
+  
+  async debuggerGetPossibleBreakpoints(parameters) {
+    return await this.send('Debugger.getPossibleBreakpoints', parameters);
+  }
+  
+  async debuggerSetBreakpointByUrl(breakpoint) {
+    return await this.send('Debugger.setBreakpointByUrl', breakpoint);
+  }
+  
+  async runtimeGetProperties(parameters) {
+    try {
+      return await this.send('Runtime.getProperties', parameters);
+    }
+    catch(err) {
+      console.log('Runtime.getProperties[callFrame]:', err);
+      return null;
+    }
+  }
+  
+  async debuggerGetScriptSource(scriptId) {
+   return await this.send('Debugger.getScriptSource', {scriptId: scriptId});
+  }
+  
+  async debuggerResume() {
+    await this.send('Debugger.resume');
+  }
+  
+  async debuggerStepOver() {
+    await this.send('Debugger.stepOver');
+  }
+  
+  async debuggerStepInto() {
+    await this.send('Debugger.stepInto');
+  }
+  
+  async debuggerStepOut() {
+    await this.send('Debugger.stepOut');
+  }
+  
+  async debuggerPause() {
+    await this.send('Debugger.pause');
+  }
+  
+  async debuggerSetPauseOnExceptions() {
+    await this.send('Debugger.setPauseOnExceptions', { state: 'all' });
+  }
+  
+  async debuggerSetAsyncCallStackDepth() {
+    await this.send('Debugger.setAsyncCallStackDepth', { maxDepth: 32 });
+  }
+  
+  async send(method, params={}) {
+    const id = ++this.idCounter;
+    const message = JSON.stringify({id, method, params});
+    this.ws.send(message);
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, {resolve, reject});
+    });
+  };
+  
+  async onMessage(event) {
+    const msg = JSON.parse(event.data);
+    if(msg.id && this.pending.has(msg.id)) {
+      const {resolve, reject} = this.pending.get(msg.id);
+      this.pending.delete(msg.id);
+      msg.error ? reject(msg.error) : resolve(msg.result);
+      return;
+    }
+    switch(msg.method) {
+      case 'Debugger.scriptParsed':
+        this.cbObject.onDebuggerScriptParsed(msg.params);
+        break;
+      case 'Debugger.paused':
+        this.cbObject.onDebuggerPaused(msg.params);
+        break;
+      case 'Debugger.resumed':
+        this.cbObject.onDebuggerResumed(msg.params);
+        break;
+    };
+  }
+}
+
+
+module.exports = Debugger;

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

@@ -0,0 +1,26 @@
+
+'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 TestCaseActorsFileGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest(actorFiles) {
+    actorFiles.forEach((file) => {
+      if(file.startsWith('./Actors-inline')) {
+        this.expectAsynchResponseSuccess(null);
+      }
+      else {
+        this.asynchReadTextFileResponse(ActorPathData.getActorFile(file));
+      }
+    });
+  }
+}
+
+
+module.exports = TestCaseActorsFileGet;

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

@@ -0,0 +1,74 @@
+
+'use strict';
+
+const StackComponentsFactory = require('z-abs-funclayer-stack-server/server/factory/stack-components-factory');
+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 TestCaseAdd extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.ADD);
+  }
+  
+  onRequest(repoName, sutName, futName, tcName, description, dataTestCase, stackName, templateName, testData) {
+    const testCase = {
+      name: tcName,
+      description: description,
+      status: 'visible',
+      tc: dataTestCase
+    }
+    const responsePart = this._verifyInput(testCase);
+    if(!responsePart) {
+      return responsePart; // ???
+    }
+    if(stackName && 'none' !== stackName) {
+      StackComponentsFactory.getStacks((stacks) => {
+        const testCaseTemplateFactory = StackComponentsFactory.createTemplatesTestCases(stackName);
+        if(testCaseTemplateFactory) {
+          const templates = new testCaseTemplateFactory().templates;
+          const template = templates.get(templateName);
+          if(template) {
+            template.createTestCase(testCase.tc, testData, repoName, sutName, futName, tcName);
+            return this._saveTestCase(repoName, sutName, futName, tcName, testCase);
+          }
+        }
+        else {
+          this._saveTestCase(repoName, sutName, futName, tcName, testCase);
+        }
+      });
+    }
+    else {
+      this._saveTestCase(repoName, sutName, futName, tcName, testCase);
+    }
+  }
+  
+  _saveTestCase(repoName, sutName, futName, tcName, testCase) {
+    Fs.mkdir(ActorPathData.getTestCaseFolder(repoName, sutName, futName, tcName), (err) => {
+      if(err) {
+        return this.responsePartError(`Could not create the Test Case Folder: ' ${ActorPathData.getTestCaseFolder(repoName, sutName, futName, tcName)} '.`);
+      }
+      Fs.writeFile(ActorPathData.getTestCaseFile(repoName, sutName, futName, tcName), JSON.stringify(testCase, null, 2), (err) => {
+        if(err) {
+          return this.responsePartError(`Could not create the TestCase File: ' ${ActorPathData.getTestCaseFile(repoName, sutName, futName, tcName)} '.`);
+        }
+        return this.responsePartSuccess();
+      });
+    });
+  }
+  
+  _verifyInput(testCase) {
+    const name = testCase.name;
+    if(0 === name.length) {
+      return this.responsePartError(`The Test Casename: '' 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 = TestCaseAdd;