@aj-shadow/actorjs-data-global 0.0.0-aj-beta.221

package/TestAbstractions/Stacks-global/puppeteer/templates-test-cases/puppeteer-page-trigger-test-case.js

@@ -0,0 +1,269 @@
+
+'use strict';
+
+const StackApi = require('stack-api');
+
+
+class PuppeteerPageTriggerTestCase extends StackApi.StackComponentsTemplatesTestCases {
+
+  static createTestCase(testCase, testData) {
+    const actor = {
+      name: 'Actors-global.wizard.puppeteer.PuppeteerPageTriggerTestCaseOrig',
+      type: 'orig',
+      phase: 'exec',
+      execution: '',
+      src: 'DEFAULT_SRC',
+      dst: '',
+      srv: '',
+      testData: '',
+      verification: ''
+    };
+    testCase.actors.push(actor);
+    
+    let dataAddressing = null;
+    let dataHeaders = null;
+    testData.forEach((testCaseDatas) => {
+      if('single' === testCaseDatas.view) {
+      }
+      /*else if('optional' === testCaseDatas.view) {
+        const optional = testCaseDatas.views[testCaseDatas.checkedOptionIndex];
+        if('hardcoded' === optional.name) {
+          dataAddressing = PuppeteerPageTriggerTestCase._addAddressHardcoded(optional.data, testCase);
+        }
+      }*/
+    });
+    /*
+    if(dataAddressing.port) {
+      actor.dst = `{"uri":"${dataAddressing.url}","port":"${dataAddressing.port}"}`;
+    }
+    else {
+      if('http' === dataAddressing.protocol) {
+        actor.dst = `{"uri":"${dataAddressing.url}","port":"80"}`;
+      }
+      else if('https' === dataAddressing.protocol) {
+        actor.dst = `{"uri":"${dataAddressing.url}","port":"443"}`;
+      }
+    }*/
+  }
+  
+  static _addAddressHardcoded(data, testCase) {
+    const dataAddressing = {
+      protocol: '',
+      url: '',
+      port: '',
+      host: ''
+    };
+    data.forEach((testCaseData) => {
+      if(testCaseData.include) {
+        if('Protocol' === testCaseData.name) {
+          dataAddressing.protocol = testCaseData.value;
+          testCase.testDataTestCases.push({
+            key: 'transport-type',
+            value: 'tls',
+            description: `Transport Type - tls`
+          });
+        }
+        if('Url' === testCaseData.name) {
+          dataAddressing.url = testCaseData.value;
+        }
+        else if('Request Target' === testCaseData.name) {
+          testCase.testDataTestCases.push({
+            key: 'request-target',
+            value: testCaseData.value,
+            description: `Http Status Line - ${testCaseData.name}`
+          });
+        }
+        else if('Port' === testCaseData.name) {
+          dataAddressing.port = testCaseData.value;
+        }
+        else if('Host' === testCaseData.name) {
+          dataAddressing.host = testCaseData.value;
+        }
+      }
+    });
+    return dataAddressing;
+  }
+  
+  static _addHeaders(data, testCase) {
+    const dataHeaders = {
+      host: ''
+    };
+    data.forEach((testCaseData) => {
+      if(testCaseData.include) {
+        const testData = {
+          key: 'http-headers[]',
+          value: `["${testCaseData.name}", "${testCaseData.value}"]`,
+          description: `Http Header - ${testCaseData.name}`
+        };
+        testCase.testDataTestCases.push(testData);
+        if('Host' === testCaseData.name) {
+          dataHeaders.host = testData;
+        }
+      }
+    });
+    return dataHeaders;
+  }
+}
+
+PuppeteerPageTriggerTestCase.displayName = 'page-trigger-test-case';
+PuppeteerPageTriggerTestCase.regressionFriendly = 'yes';
+
+PuppeteerPageTriggerTestCase.template = PuppeteerPageTriggerTestCase._template`
+
+`;
+
+PuppeteerPageTriggerTestCase.validateUrlFunctionString = `
+let urlObject = null;
+let formattedPreview = preview;
+try {
+  if('Request Target' === name) {
+    formattedPreview = 'http://www.example.com' + preview;
+  }
+  else if('Host' === name) {
+    formattedPreview = 'http://' + preview;
+  }
+  urlObject = new URL(formattedPreview);
+  if('Url' === name) {
+    if('/' === urlObject.pathname) {
+      if(urlObject.href !== preview + '/') {
+        return 3; // ERROR
+      }
+    }
+    else {
+      if(urlObject.href !== preview) {
+        return 3; // ERROR
+      }
+    }
+  }
+  else if('Host' === name && urlObject.host !== preview) {
+    return 3; // ERROR
+  }
+}
+catch(err) {
+  return 3; // ERROR
+}
+const protocol = urlObject.protocol;
+const protocolPosition = formattedPreview.lastIndexOf(protocol);
+const domainExtensionPosition = formattedPreview.lastIndexOf( '.' );
+if(0 === protocolPosition && - 1 !== ['http:', 'https:'].indexOf(protocol) && domainExtensionPosition > 2 && formattedPreview.length - domainExtensionPosition > 2) {
+  return 1; // SUCCESS
+}
+else {
+  return 3; // ERROR
+}`;
+
+PuppeteerPageTriggerTestCase.testDataViews = [
+  {
+    displayName: 'Puppeteer - Load Page',
+    name: 'Puppeteer Page - Test Case',
+    view: 'optional',
+    views: [
+      {
+        name: 'hardcoded',
+        heading: 'Hardcoded',
+        data: [
+          {
+            name: 'Protocol',
+            type: 'radio',
+            placeHolder: 'request target',
+            values: ['http', 'https'],
+            value: 'http',
+            valid: 0
+          },
+          {
+            name: 'Domain',
+            type: 'input',
+            placeHolder: 'domain',
+            value: '',
+            valid: 0
+          },
+          {
+            name: 'Port',
+            type: 'input',
+            placeHolder: 'port',
+            value: '',
+            include: 'optional:false',
+            valid: 0
+          },
+          {
+            name: 'Path',
+            type: 'input',
+            placeHolder: 'path',
+            value: '',
+            include: 'optional:false'
+          },
+          {
+            name: 'Query',
+            type: 'input',
+            placeHolder: 'query',
+            value: '',
+            include: 'optional:false',
+            valid: 0
+          },
+          {
+            name: 'Url',
+            type: 'preview',
+            value: '${Protocol}://${Domain}${Port}${Path}${Query}',
+            prefixes: [['Port', ':'], ['Path', '/'], ['Query', '?']],
+            validate: PuppeteerPageTriggerTestCase.validateUrlFunctionString,
+            valid: 1
+          },
+          {
+            name: 'Request Target',
+            type: 'preview',
+            value: '/${Path}${Query}',
+            prefixes: [['Path', '/'], ['Query', '?']],
+            validate: PuppeteerPageTriggerTestCase.validateUrlFunctionString,
+            valid: 1
+          },
+          {
+            name: 'Host',
+            type: 'preview',
+            value: '${Domain}',
+            prefixes: [],
+            validate: PuppeteerPageTriggerTestCase.validateUrlFunctionString,
+            valid: 1
+          }
+        ]
+      },
+      {
+        name: 'generated',
+        heading: 'Generated',
+        data: [
+          {
+            name: 'Request Target',
+            type: 'input',
+            placeHolder: 'request target',
+            value: ''
+          },
+          {
+            name: 'Request Target Port',
+            type: 'input',
+            placeHolder: 'port',
+            value: '80',
+            include: 'optional:false'
+          }
+        ]
+      }
+    ]
+  }
+];
+
+PuppeteerPageTriggerTestCase.markupNodes = 2;
+
+PuppeteerPageTriggerTestCase.markup = `\`\`\`seq
+Config(nodeWidth: 126, nodeMessageHeight: 17, nodeEventHeight: 10, widthBias: 23, heightBias: 20, lineNumbers: false, border: false, backgroundColor: transparent)
+
+Title: Puppeteer
+Nodes[orig, server]
+orig -o server[http]: connect
+orig => server[http]: GET
+server => orig[http]: 200 OK
+orig => server[websocket]: websocket frame
+server => orig[websocket]: websocket frame
+orig -x server[http]: disconnect
+\`\`\`
+`;
+
+
+module.exports = PuppeteerPageTriggerTestCase;

package/TestAbstractions/Stacks-global/radius/attribute-types/radius-address.js

@@ -0,0 +1,13 @@
+
+'use strict';
+
+const RadiusAttributeHeader = require('../radius-attribute-header');
+
+
+class RadiusAddress extends RadiusAttributeHeader {
+  constructor(type, value) {
+    super(type, 6, value);
+  }
+}
+
+module.exports = RadiusAddress;

package/TestAbstractions/Stacks-global/radius/attribute-types/radius-integer.js

@@ -0,0 +1,13 @@
+
+'use strict';
+
+const RadiusAttributeHeader = require('../radius-attribute-header');
+
+
+class RadiusInteger extends RadiusAttributeHeader {
+  constructor(type, value) {
+    super(type, 4, value);
+  }
+}
+
+module.exports = RadiusInteger;

package/TestAbstractions/Stacks-global/radius/attribute-types/radius-string.js

@@ -0,0 +1,13 @@
+
+'use strict';
+
+const RadiusAttributeHeader = require('../radius-attribute-header');
+
+
+class RadiusString extends RadiusAttributeHeader {
+  constructor(type, value) {
+    super(type, value.length - 2, value);
+  }
+}
+
+module.exports = RadiusString;

package/TestAbstractions/Stacks-global/radius/attributes/chap-password.js

@@ -0,0 +1,13 @@
+
+'use strict';
+
+const RadiusString = require('../attribute-types/radius-string');
+
+
+class ChapPassword extends RadiusString {
+  constructor(chapIdent, value) {
+    super(19, value);
+  }
+}
+
+module.exports = ChapPassword;

package/TestAbstractions/Stacks-global/radius/attributes/nas-ip-address.js

@@ -0,0 +1,13 @@
+
+'use strict';
+
+const RadiusAddress = require('../attribute-types/radius-address');
+
+
+class NasIpAddress extends RadiusAddress {
+  constructor(value) {
+    super(4, value);
+  }
+}
+
+module.exports = NasIpAddress;

package/TestAbstractions/Stacks-global/radius/attributes/nas-port.js

@@ -0,0 +1,13 @@
+
+'use strict';
+
+const RadiusInteger = require('../attribute-types/radius-integer');
+
+
+class NasPort extends RadiusInteger {
+  constructor(value) {
+    super(5, value);
+  }
+}
+
+module.exports = NasPort;

package/TestAbstractions/Stacks-global/radius/attributes/user-name.js

@@ -0,0 +1,13 @@
+
+'use strict';
+
+const RadiusString = require('../attribute-types/radius-string');
+
+
+class UserName extends RadiusString {
+  constructor(value) {
+    super(1, value);
+  }
+}
+
+module.exports = UserName;

package/TestAbstractions/Stacks-global/radius/attributes/user-password.js

@@ -0,0 +1,13 @@
+
+'use strict';
+
+const RadiusString = require('../attribute-types/radius-string');
+
+
+class UserPassword extends RadiusString {
+  constructor(value) {
+    super(2, value);
+  }
+}
+
+module.exports = UserPassword;

package/TestAbstractions/Stacks-global/radius/documentation/radius.md

@@ -0,0 +1,5 @@
+# **Radius**
+[[API-STATUS=EXPERIMENTAL, Not fully implemented yet.]]
+[[DOC-STATUS=NOT-YET, ]]
+
+## **Description**

package/TestAbstractions/Stacks-global/radius/msg/accept-challenge.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+const RadiusMsg = require('../radius-msg');
+const RadiusConstCode = require('../radius-const-code');
+
+
+class AccessRChallenge extends RadiusMsg {
+  constructor(identifier, authenticator, length=-1) {
+    super(RadiusConstCode.ACCESS_CHALLENGE, identifier, authenticator, length);
+    this.msg = 'Access-Challenge';
+  }
+}
+
+module.exports = AccessChallenge;

package/TestAbstractions/Stacks-global/radius/msg/access-accept.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+const RadiusMsg = require('../radius-msg');
+const RadiusConstCode = require('../radius-const-code');
+
+
+class AccessAccept extends RadiusMsg {
+  constructor(identifier, authenticator, length=-1) {
+    super(RadiusConstCode.ACCESS_ACCEPT, identifier, authenticator, length);
+    this.msg = 'Access-Accept';
+  }
+}
+
+module.exports = AccessAccept;

package/TestAbstractions/Stacks-global/radius/msg/access-reject.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+const RadiusMsg = require('../radius-msg');
+const RadiusConstCode = require('../radius-const-code');
+
+
+class AccessReject extends RadiusMsg {
+  constructor(identifier, authenticator, length=-1) {
+    super(RadiusConstCode.ACCESS_REJECT, identifier, authenticator, length);
+    this.msg = 'Access-Reject';
+  }
+}
+
+module.exports = AccessReject;

package/TestAbstractions/Stacks-global/radius/msg/access-request.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+const RadiusMsg = require('../radius-msg');
+const RadiusConstCode = require('../radius-const-code');
+
+
+class AccessRequest extends RadiusMsg {
+  constructor(identifier, authenticator, length=-1) {
+    super(RadiusConstCode.ACCESS_REQUEST, identifier, authenticator, length);
+    this.msg = 'Access-Request';
+  }
+}
+
+module.exports = AccessRequest;

package/TestAbstractions/Stacks-global/radius/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "radius-stack-api",
+  "version": "0.0.1",
+  "description": "RADIUS STACK API",
+  "main": "radius-stack-api.js",
+  "author": "ActorJs",
+  "license": ""
+}

package/TestAbstractions/Stacks-global/radius/radius-attribute-header.js

@@ -0,0 +1,18 @@
+
+'use strict';
+
+//  0                   1                   2
+//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
+// |     Type      |    Length     |  Value ...
+// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-
+     
+class RadiusAttributeHeader {
+  constructor(type, length, value) {
+    this.type = type;
+    this.length = length;
+    this.value = value;
+  }
+}
+
+module.exports = RadiusAttributeHeader;

package/TestAbstractions/Stacks-global/radius/radius-connection-client-options.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+
+class RadiusConnectionClientOptions {
+  constructor() {
+    
+  }
+  
+  clone() {
+    return new RadiusConnectionClientOptions();
+  }
+}
+
+module.exports = new RadiusConnectionClientOptions();

package/TestAbstractions/Stacks-global/radius/radius-connection-client.js

@@ -0,0 +1,25 @@
+
+'use strict';
+
+const StackApi = require('stack-api');
+const RadiusConnectionClientOptions = require('./radius-connection-client-options');
+const RadiusEncoder = require('./radius-encoder');
+const RadiusDecoder = require('./radius-decoder');
+
+
+class RadiusConnectionClient extends StackApi.ConnectionClient {
+  constructor(id, type, actor, options) {
+    super(id, type, 'radius', actor, StackApi.NetworkType.UDP, RadiusConnectionClientOptions, options);
+  }
+  
+  send(msg) {
+    this.sendMessage(new RadiusEncoder(msg));
+  }
+  
+  receive() {
+    this.receiveMessage(new RadiusDecoder());
+  }
+}
+
+
+module.exports = RadiusConnectionClient;

package/TestAbstractions/Stacks-global/radius/radius-connection-server-options.js

@@ -0,0 +1,15 @@
+
+'use strict';
+
+
+class RadiusConnectionServerOptions {
+  constructor() {
+    
+  }
+  
+  clone() {
+    return new RadiusConnectionServerOptions();
+  }
+}
+
+module.exports = new RadiusConnectionServerOptions();

package/TestAbstractions/Stacks-global/radius/radius-connection-server.js

@@ -0,0 +1,24 @@
+
+'use strict';
+
+const StackApi = require('stack-api');
+const RadiusConnectionServerOptions = require('./radius-connection-server-options');
+const RadiusEncoder = require('./radius-encoder');
+const RadiusDecoder = require('./radius-decoder');
+
+
+class RadiusConnectionServer extends StackApi.ConnectionServer {
+  constructor(id, type, actor, options) {
+    super(id, type, 'radius', actor, StackApi.NetworkType.UDP, RadiusConnectionServerOptions, options);
+  }
+  
+  receive() {
+    this.receiveMessage(new RadiusDecoder());
+  }
+  
+  send(msg) {
+    this.sendMessage(new RadiusEncoder(msg));
+  }
+}
+
+module.exports = RadiusConnectionServer;

package/TestAbstractions/Stacks-global/radius/radius-const-code.js

@@ -0,0 +1,76 @@
+
+'use strict';
+
+
+class RadiusConstCode {
+  static get(code) {
+    const codeData = RadiusConstCode.HEADER_DATA.get(code);
+    if(undefined !== codeData) {
+      return codeData;
+    }
+    else {
+      return RadiusConstCode.UNKNOWN;
+    }
+  }
+}
+
+RadiusConstCode.ACCESS_REQUEST = 1;
+RadiusConstCode.ACCESS_ACCEPT = 2;
+RadiusConstCode.ACCESS_REJECT = 3;
+RadiusConstCode.ACCOUNTING_REQUEST = 4;
+RadiusConstCode.ACCOUNTING_RESPONSE = 5;
+RadiusConstCode.ACCOUNTING_STATUS = 6;
+RadiusConstCode.PASSWORD_REQUEST = 7;
+RadiusConstCode.PASSWORD_ACK = 8;
+RadiusConstCode.PASSWORD_REJECT = 9;
+RadiusConstCode.ACCOUNTING_MESSAGE = 10;
+RadiusConstCode.ACCESS_CHALLENGE = 11;
+RadiusConstCode.STATUS_SERVER = 12;
+RadiusConstCode.STATUS_CLIENT = 13;
+/*   21       Resource-Free-Request        [RFC2882]
+   22       Resource-Free-Response       [RFC2882]
+   23       Resource-Query-Request       [RFC2882]
+   24       Resource-Query-Response      [RFC2882]
+   25       Alternate-Resource-
+            Reclaim-Request              [RFC2882]
+   26       NAS-Reboot-Request           [RFC2882]
+   27       NAS-Reboot-Response          [RFC2882]
+   28       Reserved
+   29       Next-Passcode                [RFC2882]
+   30       New-Pin                      [RFC2882]
+   31       Terminate-Session            [RFC2882]
+   32       Password-Expired             [RFC2882]
+   33       Event-Request                [RFC2882]
+   34       Event-Response               [RFC2882]
+   40       Disconnect-Request           [DynAuth]
+   41       Disconnect-ACK               [DynAuth]
+   42       Disconnect-NAK               [DynAuth]
+   43       CoA-Request                  [DynAuth]
+   44       CoA-ACK                      [DynAuth]
+   45       CoA-NAK                      [DynAuth]
+   50       IP-Address-Allocate          [RFC2882]
+   51       IP-Address-Release           [RFC2882]
+   250-253  Experimental Use
+   254      Reserved
+   255      Reserved                     [RFC2865]
+*/
+RadiusConstCode.HEADER_DATA = new Map([
+  [RadiusConstCode.ACCESS_REQUEST, {links: ['rfc2865#section-4', 'rfc2865#section-4.1'], abbrev: 'Access-Request', name: 'Access-Request'}],
+  [RadiusConstCode.ACCESS_ACCEPT, {links: ['rfc2865#section-4', 'rfc2865#section-4.2'], abbrev: 'Access-Accept', name: 'Access-Accept'}],
+  [RadiusConstCode.ACCESS_REJECT, {links: ['rfc2865#section-4', 'rfc2865#section-4.3'], abbrev: 'Access-Reject', name: 'Access-Reject'}],
+  [RadiusConstCode.ACCOUNTING_REQUEST, {links: ['rfc2866#section-4', 'rfc2866#section-4.1'], abbrev: 'Accounting-Request', name: 'Accounting-Request'}],
+  [RadiusConstCode.ACCOUNTING_RESPONSE, {links: ['rfc2866#section-4', 'rfc2866#section-4.2'], abbrev: 'Accounting-Response', name: 'Accounting-Response'}],
+  [RadiusConstCode.ACCOUNTING_STATUS, {links: ['rfc2882', 'rfc2882'], abbrev: 'Accounting-Status', name: 'Accounting-Status'}],
+  [RadiusConstCode.PASSWORD_REQUEST, {links: ['rfc2882', 'rfc2882'], abbrev: 'Password-Request', name: 'Password-Request'}],
+  [RadiusConstCode.PASSWORD_ACK, {links: ['rfc2882', 'rfc2882'], abbrev: 'Password-Ack', name: 'Password-Ack'}],
+  [RadiusConstCode.PASSWORD_REJECT, {links: ['rfc2882', 'rfc2882'], abbrev: 'Password-Reject', name: 'Password-Reject'}],
+  [RadiusConstCode.ACCOUNTING_STATUS, {links: ['rfc2882', 'rfc2882'], abbrev: 'Accounting-Message', name: 'Accounting-Message'}],
+  [RadiusConstCode.ACCESS_CHALLENGE, {links: ['rfc2865#section-4', 'rfc2865#section-4.4'], abbrev: 'Access-Challenge', name: 'Access-Challenge'}],
+  [RadiusConstCode.STATUS_SERVER, {links: ['#section-4', 'xxxxx'], abbrev: 'Status-Server', name: 'Status-Server'}],
+  [RadiusConstCode.STATUS_CLIENT, {links: ['#section-4', 'xxxxx'], abbrev: 'Status-Client', name: 'Status-Client'}]
+]);
+
+RadiusConstCode.UNKNOWN = {links: ['', ''], abbrev: 'UNKNOWN', name: 'UNKNOWN'};
+
+
+module.exports = RadiusConstCode;

package/TestAbstractions/Stacks-global/radius/radius-const.js

@@ -0,0 +1,10 @@
+
+'use strict';
+
+
+class RadiusConst {}
+
+RadiusConst.DOCUMENTATION_LINK_ROOT = 'https://tools.ietf.org/html/';
+
+
+module.exports = RadiusConst;

package/TestAbstractions/Stacks-global/radius/radius-decoder.js

@@ -0,0 +1,24 @@
+
+'use strict';
+
+const StackApi = require('stack-api');
+
+
+class RadiusDecoder extends StackApi.Decoder {
+  constructor(isLogIp) {
+    super(isLogIp);
+  }
+  
+  *decode() {
+    const msg = yield* this.receiveLine();
+    if(this.isLogIp) {
+      this.setCaption(msg);
+      this.logMessage();
+    }
+    return {
+      msg: msg
+    };
+  }
+}
+
+module.exports = RadiusDecoder;