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

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

@@ -0,0 +1,118 @@
+
+'use strict';
+
+const Debug = require('./debug');
+const DebuggerApi = require('./debugger-api');
+const ActorPathGenerated = require('z-abs-corelayer-server/server/path/actor-path-generated');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Path = require('path');
+
+
+class TestCaseDebugBreakpointSet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest(repo, sut, fut, tc, breakpoint) {
+    this.setBreakpoint(repo, sut, fut, tc, breakpoint);
+  }
+  
+  async setBreakpoint(repo, sut, fut, tc, breakpoint) {
+    const file = ActorPathGenerated.getTestCaseDebuggerFile(sut, fut, tc);
+    if(breakpoint.name.startsWith('./')) {
+      breakpoint.url = DebuggerApi.calculateBreakpointUrl(sut, fut, tc, breakpoint);
+    }
+    else {
+      breakpoint.url = breakpoint.name;
+    }
+    try {
+      const dbuggerData = await this.asynchReadFilePromise(file);
+      const debuggerApi = this.getSessionData('debugger-api');
+      if(debuggerApi) {
+        await debuggerApi._getPossibleBreakpoints(breakpoint);
+      }
+      const foundIndex = dbuggerData.breakpoints.findIndex((data) => {
+        return data.url === breakpoint.url && data.lineNumber === breakpoint.lineNumber
+      });
+      if(-1 !== foundIndex) {
+        const index = this.expectAsynchResponse();
+        this.asynchResponseSuccess(index, dbuggerData);
+        return;
+      }
+      dbuggerData.breakpoints.push(breakpoint);
+      dbuggerData.breakpoints.sort((a, b) => {
+        if(a.title !== b.title) {
+          return a.title >= b.title ? 1 : -1;
+        }
+        else if(a.lineNumber != b.lineNumber) {
+          return a.lineNumber >= b.lineNumber ? 1 : -1;
+        }
+        else {
+          return a.columnNumber >= b.columnNumber ? 1 : -1;
+        }
+      });
+      const index = this.expectAsynchResponse();
+      this.asynchWriteFile(file, dbuggerData,(err) => {
+        if(!err) {
+          if(debuggerApi) {
+            if(!debuggerApi_.findbreakpointInRunBreakpoints(breakpoint)) {
+              this._setBreakpointByUrl(debuggerApi, breakpoint, (err) => {
+                if(!err) {
+                  this.asynchResponseSuccess(index, dbuggerData);
+                }
+                else {
+                  this.asynchResponseError(err.message);
+                }
+              });
+            }
+            else {
+              this.asynchResponseSuccess(index, dbuggerData);
+            }
+          }
+          else {
+            this.asynchResponseSuccess(index, dbuggerData);
+          };
+        }
+        else {
+          this.asynchResponseError(err.message);
+        }
+      });
+    }
+    catch(err) {
+      if('ENOENT' === err.code) {
+        const parentPath = file.substring(0, file.lastIndexOf(Path.sep));
+        this.asynchMkdir(parentPath, (err) => {
+          if(!err) {
+            let dbuggerData = {
+              "breakpoints": []
+            };
+            dbuggerData.breakpoints.push(breakpoint);
+            this.asynchWriteFileResponse(file, dbuggerData, true);
+          }
+          else {
+            this.responsePartError(`Could not create dbugger file '${file}'.`);
+          }
+        }, true);
+      }
+      else {
+        this.responsePartError(`Could not read dbugger file '${file}'.`);
+      }
+    }
+  }
+  
+  async _setBreakpointByUrl(debuggerApi, breakpoint, done) {
+    try {
+      const result = await debuggerApi._setBreakpointByUrl(breakpoint);
+      breakpoint.breakpointId = result.breakpointId;
+      debuggerApi._setBreakpoint(breakpoint);
+    }
+    catch(err) {
+      ddb.error('FAILURE: ' + err);
+      return done(err);
+    };
+    done();
+  }
+}
+
+
+module.exports = TestCaseDebugBreakpointSet;

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

@@ -0,0 +1,84 @@
+
+'use strict';
+
+const DebuggerApi = require('./debugger-api');
+const ActorPathGenerated = require('z-abs-corelayer-server/server/path/actor-path-generated');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const Path = require('path');
+
+
+class TestCaseDebugBreakpointUpdate extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.UPDATE);
+  }
+  
+  onRequest(repo, sut, fut, tc, breakpoint) {
+    const file = ActorPathGenerated.getTestCaseDebuggerFile(sut, fut, tc);
+    if(breakpoint.name.startsWith('./')) {
+      breakpoint.url = DebuggerApi.calculateBreakpointUrl(sut, fut, tc, breakpoint);
+    }
+    else {
+      breakpoint.url = breakpoint.name;
+    }
+    this.asynchReadFile(file, (err, dbuggerData) => {
+      if(!err) {
+        const breakpointCurrent = dbuggerData.breakpoints.find((foundBreakpoint) => {
+          return foundBreakpoint.name === breakpoint.name
+            && foundBreakpoint.lineNumber === breakpoint.lineNumber;
+        });
+        const pauseOnBreakCurrent = breakpointCurrent.pauseOnBreak;
+        breakpointCurrent.pauseOnBreak = breakpoint.pauseOnBreak;
+        this.asynchWriteFileResponse(file, dbuggerData, true, (err) => {
+          if(!err) {
+            let debuggerApi = this.getSessionData('debugger-api');
+            if(undefined !== debuggerApi) {
+              this._updateBreakpointByUrl(debuggerApi, pauseOnBreakCurrent, breakpoint);
+            }
+          }
+        });
+      }
+      else if('ENOENT' === err.code) {
+        let parentPath = file.substring(0, file.lastIndexOf(Path.sep));
+        this.asynchMkdir(parentPath, (err) => {
+          if(!err) {
+            let dbuggerData = {
+              "breakpoints": []
+            };
+            dbuggerData.breakpoints.push(breakpoint);
+            this.asynchWriteFileResponse(file, dbuggerData, true);
+          }
+          else {
+            this.responsePartError(`Could not create dbugger file '${file}'.`);
+          }
+        }, true);
+      }
+      else {
+        this.responsePartError(`Could not read dbugger file '${file}'.`);
+      }
+    });
+  }
+  
+  async _updateBreakpointByUrl(debuggerApi, pauseOnBreakCurrent, breakpointNext) {
+    try {
+      if(pauseOnBreakCurrent !== breakpointNext.pauseOnBreak) {
+        if(breakpointNext.pauseOnBreak) {
+          let result = await debuggerApi.setBreakpointByUrl(breakpointNext);
+          breakpointNext.breakpointId = result.breakpointId;
+        }
+        else {
+          let breakpoint = debuggerApi._getBreakpoint(breakpointNext);
+          await debuggerApi.removeBreakpoint(breakpoint);
+          debuggerApi._removeBreakpoint(breakpointNext);    
+          breakpointNext.breakpointId = '';
+          
+        }
+        debuggerApi._setBreakpoint(breakpointNext);
+      }
+    }
+    catch(err) {
+      ddb.error('FAILURE: ' + err);
+    };
+  }
+}
+
+module.exports = TestCaseDebugBreakpointUpdate;

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

@@ -0,0 +1,40 @@
+
+'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 Path = require('path');
+
+
+class TestCaseDebugGet extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest(repo, sut, fut, tc) {
+    const file = ActorPathGenerated.getTestCaseDebuggerFile(sut, fut, tc);
+    this.asynchReadFile(file, (err, dbuggerData) => {
+      if(!err) {
+        this.expectAsynchResponseSuccess(dbuggerData);
+      }
+      else if('ENOENT' === err.code) {
+        const parentPath = file.substring(0, file.lastIndexOf(Path.sep));
+        this.asynchMkdir(parentPath, (err) => {
+          if(!err) {
+            this.asynchWriteFileResponse(file, {
+              "breakpoints": []
+            }, true);
+          }
+          else {
+            this.expectAsynchResponseError(`Could not create dbugger file '${file}'.`);
+          }
+        }, true);
+      }
+      else {
+        this.expectAsynchResponseError(`Could not read dbugger file '${file}'.`);
+      }
+    });
+  }
+}
+
+module.exports = TestCaseDebugGet;

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

@@ -0,0 +1,40 @@
+
+'use strict';
+
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class TestCaseDebugGetMembers extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest(parameters) {
+    this.getMembers(parameters);
+  }
+  
+  async getMembers(parameters) {
+    const debuggerApi = this.getSessionData('debugger-api');
+    try {
+      if(!parameters.objectId) {
+        this.expectAsynchResponseSuccess([]);
+        return;
+      }
+      const members = await debuggerApi.runtimeGetProperties(parameters);
+      if('object' === parameters.type && 'map' === parameters.subtype) {
+        const internalProperties = await debuggerApi.runtimeGetProperties(members.internalProperties[1].value);
+        members.extraResult = internalProperties.result;
+      }
+      else if('object' === parameters.type && 'proxy' === parameters.subtype) {
+        const internalProperties = await debuggerApi.runtimeGetProperties(members.internalProperties[1].value);
+        members.extraResult = internalProperties.result;
+      }
+      this.expectAsynchResponseSuccess(members);
+    }
+    catch(err) {
+      this.expectAsynchResponseError(`Could not get the debug members of ${JSON.stringify(object, null, 2)}`);
+    }
+  }
+}
+
+module.exports = TestCaseDebugGetMembers;

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

@@ -0,0 +1,47 @@
+
+'use strict';
+
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class TestCaseDebugGetProperty extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest(object, memberNameArray) {
+    this.getProperty({value: object}, memberNameArray);
+  }
+  
+  async getProperty(object, memberNameArray) {
+    let debuggerApi = this.getSessionData('debugger-api');
+    try {
+      let members = null;
+      for(let i = 1; i < memberNameArray.length; ++i) {
+        members = await debuggerApi.runtimeGetProperties({objectId: object.value});
+        object = members.result.find((member) => {
+          return member.name === memberNameArray[i];
+        });
+      }
+      if(undefined !== object && undefined !== object.value) {
+        if('object' === object.value.type && null !== object.value.value) {
+          members = await debuggerApi.runtimeGetProperties({objectId: object.value});
+          object.members = members;
+        }
+      }
+      else {
+        object = {
+          value: {
+            type: 'undefined'            
+          }
+        }
+      }
+      this.expectAsynchResponseSuccess(object);
+    }
+    catch(err) {
+      this.expectAsynchResponseError(`Could not get the debug members of ${JSON.stringify(object, null, 2)}`);
+    }
+  }
+}
+
+module.exports = TestCaseDebugGetProperty;

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

@@ -0,0 +1,29 @@
+
+'use strict';
+
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+
+
+class TestCaseDebugGetSource extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+  }
+  
+  onRequest(scriptId) {
+    this.getSource(scriptId);
+  }
+  
+  async getSource(scriptId) {
+    debugger
+    const debuggerApi = this.getSessionData('debugger-api');
+    try {
+      const source = await debuggerApi.getDebuggerScriptSource({scriptId: scriptId});
+      this.expectAsynchResponseSuccess(source.scriptSource);
+    }
+    catch(err) {
+      this.expectAsynchResponseError(`Could not get the debug script source of script with scriptId: '${scriptId}'.`);
+    }    
+  }
+}
+
+module.exports = TestCaseDebugGetSource;

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

@@ -0,0 +1,35 @@
+
+'use strict';
+
+const TestCaseLoader = require('z-abs-funclayer-engine-server/server/engine/test-case-loader');
+const Logger = require('z-abs-corelayer-server/server/log/logger');
+const ActorPathData = require('z-abs-corelayer-server/server/path/actor-path-data');
+const PluginBase = require('z-abs-corelayer-server/server/plugin-base');
+const Fs = require('fs');
+
+
+class TestCaseDebugLoad extends PluginBase {
+  constructor() {
+    super(PluginBase.GET);
+  }
+  
+  onRequest(repoName, sutName, futName, tcName, sutInstance, config) {
+    TestCaseLoader.load(repoName, sutName, futName, tcName, sutInstance, [], true, config, this.cbMessage, (err, testCase) => {
+      if(err) {
+        if('N/A' === err.message) {
+          return this.responsePartError('N/A');
+        }
+        else {
+          LOG_ERROR(Logger.ERROR.CATCH, this.constructor.name, err);
+          return this.responsePartError(`Could not find the Test Case: '${ActorPathData.getTestCaseFile(repoName, sutName, futName, tcName)}'`);
+        }
+      }
+      else {
+        this.setSessionData('TEST_CASE', testCase);
+        return this.responsePartSuccess();
+      }
+    });
+  }
+}
+
+module.exports = TestCaseDebugLoad;

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

@@ -0,0 +1,52 @@
+
+'use strict';
+
+const PluginBase = require('z-abs-corelayer-server/server/plugin-base');
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+
+
+class TestCaseDebugRun extends PluginBase {
+  constructor() {
+    super(PluginBase.GET);
+  }
+  
+  onRequest() {
+    const testCase = this.getSessionData('TEST_CASE');
+    if(null !== testCase) {
+      process.nextTick((self, testCase) => {
+        testCase.executionContext.initTestCase(testCase);
+        testCase.run((done) => {
+          testCase.executionContext.exitTestCase(testCase, done);
+          self.onClose(() => {});
+        });
+      }, this, testCase);
+      return this.responsePartSuccess();
+    }
+    return this.responsePartError('No Test Case found.');
+  }
+  
+  onMessageFromClient(msg) {
+    if(AppProtocolConst.TEST_CASE_STOP === msg.msgId) {
+      const testCase = this.getSessionData('TEST_CASE');
+      if(null !== testCase) {
+        testCase.stop();
+      }
+    }
+    else if(AppProtocolConst.TEST_CASE_DEBUG_ACTOR_INDEX_OK === msg.msgId) {
+      const testCase = this.getSessionData('TEST_CASE');
+      if(null !== testCase) {
+        testCase.actorDebugContinue(msg.actorIndex);
+      }
+    }
+  }
+  
+  onClose(done) {
+    const testCase = this.getSessionData('TEST_CASE');
+    if(null !== testCase) {
+      testCase.stop(done);
+    }
+  }
+}
+
+
+module.exports = TestCaseDebugRun;

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

@@ -0,0 +1,217 @@
+
+'use strict';
+
+const Debug = require('./debug');
+const Debugger = require('./debugger');
+const DebuggerApi = require('./debugger-api');
+const MessageTestCaseDebugActorIndexOk = require('z-abs-funclayer-engine-server/server/communication/messages/messages-s-to-w/message-test-case-debug-actor-index-ok');
+const MessageTestCaseDebugPaused = require('z-abs-funclayer-engine-server/server/communication/messages/messages-s-to-c/message-test-case-debug-paused');
+const AppProtocolConst = require('z-abs-funclayer-engine-cs/clientServer/communication/app-protocol/app-protocol-const');
+const ActorPathGenerated = require('z-abs-corelayer-server/server/path/actor-path-generated');
+const PluginBaseMulti = require('z-abs-corelayer-server/server/plugin-base-multi');
+const ActionRequest = require('z-abs-corelayer-cs/clientServer/communication/action-request');
+const Path = require('path');
+
+
+class TestCaseDebugStart extends PluginBaseMulti {
+  constructor() {
+    super(PluginBaseMulti.GET);
+    this.actorIndex = -1;
+    this.debugger = null;
+    this.debuggerApi = null;
+    this.client = null;
+    this.processStarted = false;
+    this.logFileLoaded = false;
+    this.testCaseDebugRunStarted = false;
+    this.breakOnEnterRun = false;
+    this.breakOnLeaveRun = false;
+    this.runBreakpoints = [];
+    this.breakpoints = [];
+    this.debugType = 0; // Local
+    this.sutName = '';
+    this.futName = '';
+    this.tcName = '';
+  }
+  
+  onRequest(repoName, sutName, futName, tcName, sutInstance, nodes, config) {
+    this.breakOnEnterRun = config.breakOnEnterRun;
+    this.breakOnLeaveRun = config.breakOnLeaveRun;
+    this.runBreakpoints = config.breakOnLines;
+    this.debugType = config.debugType;
+    this.sutName = sutName;
+    this.futName = futName;
+    this.tcName = tcName;
+    this._startWorkerProcess(repoName, sutName, futName, tcName, sutInstance, config, (sessionData) => {
+      this._readDebuggerFile(sutName, futName, tcName, sessionData);
+    });
+  }
+  
+  onMessageFromClient(msg) {
+    this._onMessageFromClient(msg);
+  }
+  
+  async _onMessageFromClient(msg) {
+    if(AppProtocolConst.TEST_CASE_DEBUG_CONTINUE === msg.msgId) {
+      await this.debuggerApi.onDebuggerContinue();
+    }
+    else if(AppProtocolConst.TEST_CASE_DEBUG_STEP_OVER === msg.msgId) {
+      await this.debuggerApi.onDebuggerStepOver();
+    }
+    else if(AppProtocolConst.TEST_CASE_DEBUG_STEP_IN === msg.msgId) {
+      await this.debuggerApi.onDebuggerStepInto();
+    }
+    else if(AppProtocolConst.TEST_CASE_DEBUG_STEP_OUT === msg.msgId) {
+      await this.debuggerApi.onDebuggerStepOut();
+    }
+    else if(AppProtocolConst.TEST_CASE_DEBUG_PAUSE === msg.msgId) {
+      await this.debuggerApi.onDebuggerPause();
+    }
+  }
+  
+  onDebuggerScriptParsed(parameters) {
+    this.debuggerApi._scriptParsed(parameters);
+  }
+  
+  async onDebuggerPaused(parameters) {
+    try {
+      const responseData = await this.debuggerApi.onDebuggerPaused(parameters);
+      if(responseData) {
+        this.sendMessage(new MessageTestCaseDebugPaused(responseData.stack, responseData.scriptId, responseData.script, this.actorIndex), null, true);
+      }
+    }
+    catch(err) {
+      console.log(err);
+    }
+  }
+  
+  onDebuggerResumed(parameters) {}
+  
+  onMessageFromWorker(msg, dataBuffers, debug, cbMessage) {
+    if(AppProtocolConst.TEST_CASE_STOPPED === msg.msgId && msg.last) {
+      this.onClose(() => {
+        cbMessage(msg, dataBuffers, debug);
+        this.clearSession(() => {});
+      });
+    }
+    else if(AppProtocolConst.TEST_CASE_DEBUG_ACTOR_INDEX === msg.msgId) {
+      this.actorIndex = msg.actorIndex;
+      this.sendMessageToWorkerProcess(new MessageTestCaseDebugActorIndexOk(this.requestData.sessionId, this.actorIndex));
+    }
+    else {
+      cbMessage(msg, dataBuffers, debug);
+    }
+  }
+  
+  async close(done) {
+    if(this.debugger) {
+      this.debugger.close();
+      this.debugger = null;
+      this.debuggerApi = null;
+      process.nextTick(done);
+    }
+    else {
+      process.nextTick(done);
+    }
+  }
+  
+  onClose(done) {
+    this.close(done);
+  }
+  
+  _startWorkerProcess(repoName, sutName, futName, tcName, sutInstance, config, done) {
+    this.expectAsynchResponseTemp();
+    this.forkWorkerProcess('server-test-case', [`test-case${Path.sep}plugin_data_TestCaseDebugLoad.js`, `test-case${Path.sep}plugin_data_TestCaseDebugRun.js`], true, ['127.0.0.1', false, this.debugType], (pid, sessionData) => {
+      this._loadTestCase(repoName, sutName, futName, tcName, sutInstance, config, sessionData);
+      this.unExpectAsynchResponseTemp();
+      done(sessionData);
+    });
+  }
+  
+  _loadTestCase(repoName, sutName, futName, tcName, sutInstance, config, sessionData) {
+    const indexDebugLoad = this.expectAsynchResponse();
+    const testCaseDebugLoadRequest = new ActionRequest();
+    testCaseDebugLoadRequest.add('TestCaseDebugLoad', 0, repoName, sutName, futName, tcName, sutInstance, config);
+    this.sendRequestToWorkerProcess(testCaseDebugLoadRequest, (response) => {
+      const result = response.responses[0].result;
+      if('TestCaseDebugLoad' === response.responses[0].name && 'success' === result.code) {
+        this.processStarted = true;
+        this.startDebugger(sessionData);
+        this.asynchResponseSuccess(indexDebugLoad);
+      }
+      else {
+        this.asynchResponseError(result.msg, indexDebugLoad);
+        this.clearSession();
+      }
+    });
+  }
+  
+  _readDebuggerFile(sutName, futName, tcName, sessionData) {
+    const file = ActorPathGenerated.getTestCaseDebuggerFile(sutName, futName, tcName);
+    this.asynchReadFile(file, (err, dbuggerData) => {
+      if(!err) {
+        this.logFileLoaded = true;
+        this.breakpoints = dbuggerData.breakpoints;
+        this.startDebugger(sessionData);
+      }
+      else if('ENOENT' === err.code) {
+        const parentPath = file.substring(0, file.lastIndexOf(Path.sep));
+        this.asynchMkdir(parentPath, (err) => {
+          if(!err) {
+            this.logFileLoaded = true;
+            this.startDebugger(sessionData);
+          }
+          else {
+            this.expectAsynchResponseError(`Could not read dbugger file '${file}'.`);
+          }
+        }, true);
+      }
+      else {
+        this.expectAsynchResponseError(`Could not read dbugger file '${file}'.`);
+      }
+    });
+  }
+  
+  _startDebugger(done) {
+    this.setSessionData('client', this.client);
+    const indexDebugRun = this.expectAsynchResponse();
+    const testCaseDebugRunRequest = new ActionRequest();
+    testCaseDebugRunRequest.add('TestCaseDebugRun');
+    this.sendRequestToWorkerProcess(testCaseDebugRunRequest, (response) => {
+      this.testCaseDebugRunStarted = true;
+      done();
+      this.asynchResponseSuccess(indexDebugRun);
+    });  
+  }
+  
+  startDebugger(sessionData) {
+    if(this.processStarted && this.logFileLoaded) {
+      const indexDebugger = this.expectAsynchResponse();
+      this.debugger = new Debugger(sessionData, this);
+      this.debugger.connect((err) => {
+        if(!err) {
+          this._startDebugger(async () => {
+            this.debuggerApi = new DebuggerApi(this.debugger);
+            this.setSessionData('debugger-api', this.debuggerApi);
+            if(0 !== this.breakpoints.length) {
+              this.debuggerApi._setBreakpoints(this.breakpoints);
+            }
+            this.runBreakpoints.forEach((runBreakpoint) => {
+              runBreakpoint.url = this.debuggerApi.calculateBreakpointUrl(this.sutName, this.futName, this.tcName, runBreakpoint);
+            });
+            await this.debugger.debuggerEnable();
+            await this.debuggerApi.onDebuggerEnabled();
+            //await this.debugger.debuggerSetPauseOnExceptions();
+            await this.debugger.debuggerSetAsyncCallStackDepth();
+            this.asynchResponseSuccess(indexDebugger);
+          });
+        }
+        else {
+          this.asynchResponseError('Could not create debugger.', indexDebugger);
+        }
+      });
+    }
+  }
+}
+
+
+module.exports = TestCaseDebugStart;

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

@@ -0,0 +1,23 @@
+
+'use strict';
+
+const PluginBase = require('z-abs-corelayer-server/server/plugin-base');
+
+
+class TestCaseDebugStop extends PluginBase {
+  constructor() {
+    super(PluginBase.GET);
+  }
+  
+  onRequest() {
+    //let client = this.getSessionData('debugger-api');
+    setTimeout(() => {
+      ddb.info('CLOSE:::::::::::::::::');
+      this.killWorkerProcess(() => {
+        this.responsePartSuccess();
+      });
+    }, 0);
+  }
+}
+
+module.exports = TestCaseDebugStop;