@gregoriusrippenstein/erlang-red-unittest 0.9.1

package/nodes/ut-assert-status.html

@@ -0,0 +1,199 @@
+<script type="text/javascript">
+  (function(){
+  
+
+  function frontendSupportFunction() {
+  }
+
+  var functTwo = (arg) => {
+
+  };
+  
+  RED.nodes.registerType('ut-assert-status',{
+    color: '#C0DEED',
+    icon: "font-awesome/fa-window-minimize",
+    category: 'testing',
+    paletteLabel: 'Assert Status',
+    defaults: {
+      name: {
+        value:"",
+      },
+      nodeid: {
+        value: "",
+        required: true
+      },
+      content: {
+        value: "",
+      },
+      colour: {
+        value: "grey",
+        required: true
+      },
+      shape: {
+        value: "dot",
+        required: true
+      },
+      inverse: {
+        value: false,
+        required: true
+      }
+    },
+
+    inputs: 0,
+
+    outputs: 0,
+
+    label: function() {
+      if ( this.nodeid && !this.name) {
+        let nodeLabel = `[${this.nodeid}]`;
+        let node = RED.nodes.node(this.nodeid)
+        if (node) {
+          nodeLabel = RED.utils.getNodeLabel(node)
+        }
+        
+        if ( this.inverse )  {
+          return `Assert No Status for ${nodeLabel}`
+        } else {
+          return `Assert Status for ${nodeLabel}: ${this.colour} ${this.shape}`
+        }
+      } else { return (this.name || this._def.paletteLabel) }
+    },
+
+    labelStyle: function() {
+      return (this.name || this.nodeid) ? "node_label_italic" : "";
+    },
+
+    onpaletteadd: function() {
+    },
+
+    onpaletteremove: function() {
+    },
+
+    oneditprepare: function() {
+      $('#node-input-inverse').on('change', () => {
+        if ($('#node-input-inverse').is(":checked")) {
+          $('#ut-assert-status-opts-to-hide-on-inverse').fadeOut(300);
+        } else {
+          $('#ut-assert-status-opts-to-hide-on-inverse').fadeIn(300);
+        }
+      });
+
+      var dirList = $("#node-input-assert-status-target-container-div").css({
+        width: "100%",
+        height: "calc(100%)"
+      }).treeList(
+        {
+          multi: false
+        }
+      ).on('treelistselect', function (event, item) {
+        if (item && item.nodeid) {
+          RED.view.reveal(item.nodeid);
+          RED.view.select(item.nodeid);
+        }        
+      }).on('treelistconfirm', function (event, item) {
+      });
+
+      var search = $("#node-input-assert-status-target-filter").searchBox({
+        style: "compact",
+        delay: 300,
+        change: function () {
+          var val = $(this).val().trim().toLowerCase();
+          if (val === "") {
+            dirList.treeList("filter", null);
+            search.searchBox("count", "");
+          } else {
+            var count = dirList.treeList("filter", function (item) {
+              return item.label.toLowerCase().indexOf(val) > -1 || item.sublabel.toLowerCase().indexOf(val) > -1
+            });
+            search.searchBox("count", count + " / " + dirList.treeList("data").length);
+          }
+        }
+      });
+
+      let data = RED.nodes.filterNodes({ z: RED.workspaces.active() }).filter(n => n.id != this.id).map(nde => {
+        return {
+          label: RED.utils.getNodeLabel(nde),
+          icon: "",
+          nodeid: nde.id,
+          sublabel: nde.type,
+          selected: nde.id == this.nodeid,
+          checkbox: false,
+          radio: true,
+          children: undefined
+        }
+      })
+
+      dirList.treeList('data', data)      
+    },
+
+    oneditcancel: function() {
+    },
+
+    oneditsave: function() {
+      this.nodeid = $("#node-input-assert-status-target-container-div").treeList('selected').nodeid;
+    },
+
+    oneditresize: function(size) {
+    },
+
+
+  });
+})();
+
+</script>
+
+<script type="text/html" data-template-name="ut-assert-status">
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="node-red:common.label.name"></span></label>
+    <input type="text" id="node-input-name" data-i18n="[placeholder]node-red:common.label.name">
+  </div>
+
+  <div class="form-row">
+    <input type="checkbox" id="node-input-inverse"
+             style="display:inline-block; width:15px; vertical-align:baseline;">
+    <label for="node-input-inverse"><span data-i18n="ut-assert-status.label.inverse"></span></label>
+  </div>
+
+  <div id="ut-assert-status-opts-to-hide-on-inverse">
+    <div class="form-row">
+      <label for="node-input-content"><i class="fa fa-tag"></i> <span data-i18n="ut-assert-status.label.content"></span></label>
+      <input type="text" id="node-input-content" data-i18n="[placeholder]ut-assert-status.label.content">
+    </div>
+
+    <div class="form-row">
+      <label for="node-input-colour">
+            <i class="fa fa-tag"></i>
+            <span>Colour</span>
+          </label>
+    
+      <select id="node-input-colour">
+        <option value="red" selected=selected>Red</option>
+        <option value="grey">Grey</option>
+        <option value="blue">Blue</option>
+        <option value="yellow">Yellow</option>
+        <option value="green">Green</option>
+      </select>
+    </div>
+
+    <div class="form-row">
+      <label for="node-input-shape">
+            <i class="fa fa-tag"></i>
+            <span>Shape</span>
+          </label>
+    
+      <select id="node-input-shape">
+        <option value="dot" selected=selected>Dot</option>
+        <option value="ring">Ring</option>
+      </select>
+    </div>
+  </div>
+
+
+    <div class="form-row" style="margin-left: 10px; position: relative; height: 40vh; margin-right: 15px; min-height: 5vh;"">
+          <div style=" margin-bottom: 5px; width: 35%; padding-left: 60%;">
+      <input type="text" id="node-input-assert-status-target-filter">
+    </div>
+    
+    <div id="node-input-assert-status-target-container-div"></div>
+    </div>
+</script>

package/nodes/ut-assert-status.js

@@ -0,0 +1,38 @@
+module.exports = function(RED) {
+  function Coreut_assert_statusFunctionality(config) {
+    RED.nodes.createNode(this,config);
+
+    var node = this;
+    var cfg = config;
+
+    node.on('close', function() {
+      node.status({});
+    });
+
+    /* msg handler, in this case pass the message on unchanged */
+    node.on("input", function(msg, send, done) {
+        // How to send a status update
+        node.status({ fill: "green", shape: "ring", text: RED._("ut-assert-status.label.statusset") });
+
+        // Send a message and how to handle errors.
+        try {
+          try {
+            send(msg);
+            done();
+          } catch ( err ) {
+            // use node.error if the node might send subsequent messages
+            node.error("error occurred", { ...msg, error: err })
+            done();
+          }
+        } catch (err) {
+          // use done if the node won't send anymore messages for the
+          // message it received.
+          msg.error = err
+          done(err.message, msg)
+        }
+    });
+  }
+
+  RED.nodes.registerType("ut-assert-status", Coreut_assert_statusFunctionality);
+
+}

package/nodes/ut-assert-success.html

@@ -0,0 +1,64 @@
+<script type="text/javascript">
+  (function(){
+  
+
+  function frontendSupportFunction() {
+  }
+
+  var functTwo = (arg) => {
+
+  };
+  
+  RED.nodes.registerType('ut-assert-success',{
+    color: '#addb7b',
+    icon: "font-awesome/fa-smile-o",
+    category: 'testing',
+    defaults: {
+      name: {
+        value:"",
+      },
+    },
+
+    paletteLabel: "Assert True",
+    inputs: 1,
+
+    outputs: 0,
+
+    label: function() {
+      return (this.name || this._def.paletteLabel);
+    },
+
+    labelStyle: function() {
+      return this.name?"node_label_italic":"";
+    },
+
+    onpaletteadd: function() {
+    },
+
+    onpaletteremove: function() {
+    },
+
+    oneditprepare: function() {
+    },
+
+    oneditcancel: function() {
+    },
+
+    oneditsave: function() {
+    },
+
+    oneditresize: function(size) {
+    },
+
+
+  });
+})();
+
+</script>
+
+<script type="text/html" data-template-name="ut-assert-success">
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="node-red:common.label.name"></span></label>
+    <input type="text" id="node-input-name" data-i18n="[placeholder]node-red:common.label.name">
+  </div>
+</script>

package/nodes/ut-assert-success.js

@@ -0,0 +1,38 @@
+module.exports = function(RED) {
+  function CoreutassertsuccessFunctionality(config) {
+    RED.nodes.createNode(this,config);
+
+    var node = this;
+    var cfg = config;
+
+    node.on('close', function() {
+      node.status({});
+    });
+
+    /* msg handler, in this case pass the message on unchanged */
+    node.on("input", function(msg, send, done) {
+        // How to send a status update
+      node.status({ fill: "green", shape: "ring", text: RED._("ut-assert-success.label.succeed") });
+
+        // Send a message and how to handle errors.
+        try {
+          try {
+            send(msg);
+            done();
+          } catch ( err ) {
+            // use node.error if the node might send subsequent messages
+            node.error("error occurred", { ...msg, error: err })
+            done();
+          }
+        } catch (err) {
+          // use done if the node won't send anymore messages for the
+          // message it received.
+          msg.error = err
+          done(err.message, msg)
+        }
+    });
+  }
+
+  RED.nodes.registerType("ut-assert-success", CoreutassertsuccessFunctionality);
+
+}

package/nodes/ut-assert-values.html

@@ -0,0 +1,288 @@
+<script type="text/javascript">
+  (function(){
+  
+  RED.nodes.registerType('ut-assert-values',{
+    color: '#FDF0C2',
+    icon: "font-awesome/fa-exclamation",
+    category: 'testing',
+    defaults: {
+      name: {
+        value:"",
+      },
+      rules: {
+        value: [{ t: "eql", p: "payload", pt: "msg", to: "", tot: "str" }],
+        validate: function (rules, opt) {
+          let msg;
+          const errors = []
+          if (!rules || rules.length === 0) { return true }
+          for (var i = 0; i < rules.length; i++) {
+            const opt = { label: RED._('ut-assert-values.label.rule') + ' ' + (i + 1) }
+            const r = rules[i];
+            if (r.t === 'eql' || r.t === 'noteql' || r.t === 'mth' || r.t === 'notmth' || r.t === 'debug' || r.t === 'notset' ||  r.t === 'set') {
+              if ((msg = RED.utils.validateTypedProperty(r.p, r.pt, opt)) !== true) {
+                errors.push(msg)
+              }
+            }
+            if (r.t === 'eql' || r.t === 'noteql' || r.t === 'mth' || r.t === 'notmth') {
+              if ((msg = RED.utils.validateTypedProperty(r.to, r.tot, opt)) !== true) {
+                errors.push(msg)
+              }
+            }
+          }
+          if (errors.length) {
+            return errors
+          }
+          return true;
+        }
+      },
+
+    },
+    
+    paletteLabel: 'Assert Values',
+    inputs: 1,
+
+    outputs: 1,
+
+    label: function () {
+      function prop2name(type, key) {
+        var result = RED.utils.parseContextKey(key);
+        return type + "." + result.key;
+      }
+      if (this.name) {
+        return this.name;
+      }
+      if ( this.rules) {
+        if (this.rules.length == 1) {
+          return this._("ut-assert-values.label." + this.rules[0].t, { property: prop2name((this.rules[0].pt || "msg"), this.rules[0].p) });
+        } else {
+          return this._("ut-assert-values.label.changeCount", { count: this.rules.length });
+        }
+      }
+    },
+
+    labelStyle: function() {
+      return this.name?"node_label_italic":"";
+    },
+
+    onpaletteadd: function() {
+    },
+
+    onpaletteremove: function() {
+    },
+
+    oneditprepare: function() {
+      var to = this._("ut-assert-values.action.to");
+      var toValueLabel = this._("ut-assert-values.action.toValue", to);
+      var search = this._("ut-assert-values.action.search");
+      var replace = this._("ut-assert-values.action.replace");
+      var regex = this._("ut-assert-values.label.regex");
+
+      var node = this;
+
+      function createPropertyValue(row2_1, row2_2, defaultType) {
+        var propValInput = $('<input/>', { class: "node-input-rule-property-value", type: "text" })
+          .appendTo(row2_1)
+          .typedInput({ default: defaultType || 'str', types: ['msg', 'flow', 'global', 'str', 'num', 'bool', 'json', 'bin', 'date', 'jsonata', 'env'] });
+
+        propValInput.on("change", function (evt, type, val) {
+          row2_2.toggle(type === "msg" || type === "flow" || type === "global" || type === "env");
+        })
+        return [propValInput, undefined];
+      }
+
+
+      function createFromValue(row3_1, defaultType) {
+        return $('<input/>', { class: "node-input-rule-property-search-value", type: "text" })
+          .appendTo(row3_1)
+          .typedInput({ default: defaultType || 'str', types: ['msg', 'flow', 'global', 'str', 're', 'num', 'bool', 'env'] });
+      }
+
+
+      function createToValue(row3_2, defaultType) {
+        return $('<input/>', { class: "node-input-rule-property-replace-value", type: "text" })
+          .appendTo(row3_2)
+          .typedInput({ default: defaultType || 'str', types: ['msg', 'flow', 'global', 'str', 'num', 'bool', 'json', 'bin', 'env'] });
+      }
+
+
+      function createMoveValue(row4, defaultType) {
+        return $('<input/>', { class: "node-input-rule-property-move-value", type: "text" })
+          .appendTo(row4)
+          .typedInput({ default: defaultType || 'msg', types: ['msg', 'flow', 'global'] });
+      }
+
+      $('#node-input-assert-values-rule-container').css('min-height', '150px').css('min-width', '450px').editableList({
+        addItem: function (container, i, opt) {
+          var rule = opt;
+          if (!rule.hasOwnProperty('t')) {
+            rule = { t: "eql", p: "payload", to: "", tot: "str" };
+          }
+          container.css({
+            overflow: 'hidden',
+            whiteSpace: 'nowrap'
+          });
+          let fragment = document.createDocumentFragment();
+          var row1 = $('<div/>', { style: "display:flex; align-items: baseline" }).appendTo(fragment);
+          var row2 = $('<div/>', { style: "margin-top:8px;" }).appendTo(fragment);
+          var row3 = $('<div/>', { style: "margin-top:8px;" }).appendTo(fragment);
+          var row4 = $('<div/>', { style: "display:flex;margin-top:8px;align-items: baseline" }).appendTo(fragment);
+
+          var selectField = $('<select/>', { class: "node-input-rule-type", style: "width:110px; margin-right:10px;" }).appendTo(row1);
+          var selectOptions = [
+            { v: "eql" }, 
+            { v: "noteql" }, 
+            { v: "mth" }, 
+            { v: "notmth" },
+            { v: "set" },
+            { v: "notset" },
+            { v: "debug" },
+          ];
+          for (var i = 0; i < selectOptions.length; i++) {
+            let label = node._("ut-assert-values.action." + (selectOptions[i].l || selectOptions[i].v))
+            selectField.append($("<option></option>").val(selectOptions[i].v).text(label));
+          }
+
+          var propertyName = $('<input/>', { class: "node-input-rule-property-name", type: "text" })
+            .appendTo(row1)
+            .typedInput({ types: ['msg', 'flow', 'global'] });
+
+          var row2_1 = $('<div/>', { style: "display:flex;align-items: baseline" }).appendTo(row2);
+          $('<div/>', { style: "display:inline-block;text-align:right; width:120px; padding-right:10px; box-sizing:border-box;" })
+            .text(toValueLabel)
+            .appendTo(row2_1);
+
+          var row2_2 = $('<div/>', { style: "margin-top: 4px;" }).appendTo(row2);
+
+          var row3_1 = $('<div/>', { style: "display:flex;align-items: baseline" }).appendTo(row3);
+          $('<div/>', { style: "display:inline-block;text-align:right; width:120px; padding-right:10px; box-sizing:border-box;" })
+            .text(search)
+            .appendTo(row3_1);
+
+          var row3_2 = $('<div/>', { style: "display:flex;margin-top:8px;align-items: baseline" }).appendTo(row3);
+          $('<div/>', { style: "display:inline-block;text-align:right; width:120px; padding-right:10px; box-sizing:border-box;" })
+            .text(replace)
+            .appendTo(row3_2);
+
+          $('<div/>', { style: "display:inline-block;text-align:right; width:120px; padding-right:10px; box-sizing:border-box;" })
+            .text(to)
+            .appendTo(row4);
+
+          let propertyValue = null;
+          let fromValue = null;
+          let toValue = null;
+          let moveValue = null;
+
+          selectField.on("change", function () {
+            var type = $(this).val();
+            if (propertyValue) {
+              propertyValue.typedInput('hide');
+            }
+            if (fromValue) {
+              fromValue.typedInput('hide');
+            }
+            if (toValue) {
+              toValue.typedInput('hide');
+            }
+            if (moveValue) {
+              moveValue.typedInput('hide');
+            }
+
+            if (type != "notset" && type != "debug" && type != "set") {
+              if (!propertyValue) {
+                var parts = createPropertyValue(row2_1, row2_2);
+                propertyValue = parts[0];
+              }
+              
+              propertyValue.typedInput('show');
+              propertyValue.typedInput('value', rule.to);
+              propertyValue.typedInput('type', rule.tot);
+
+              row2.show();
+              row3.hide();
+              row4.hide();
+            } else {
+              row2.hide();
+              row3.hide();
+              row4.hide();
+            }
+          });
+
+          selectField.val(rule.t);
+          propertyName.typedInput('value', rule.p);
+          propertyName.typedInput('type', rule.pt);
+          selectField.change();
+          container[0].appendChild(fragment);
+        },
+        removable: true,
+        sortable: true
+      });
+
+      for (var i = 0; i < this.rules.length; i++) {
+        var rule = this.rules[i];
+        $("#node-input-assert-values-rule-container").editableList('addItem', rule);
+      }
+    },
+
+    oneditcancel: function() {
+    },
+
+    oneditsave: function() {
+      var rules = $("#node-input-assert-values-rule-container").editableList('items');
+
+      var node = this;
+      node.rules = [];
+
+      rules.each(function (i) {
+        var rule = $(this);
+        var type = rule.find(".node-input-rule-type").val();
+
+        var r = {
+          t: type,
+          p: rule.find(".node-input-rule-property-name").typedInput('value'),
+          pt: rule.find(".node-input-rule-property-name").typedInput('type')
+        };
+
+        if (type !== "notset" && type !== "debug" && type !== "set") {
+          r.to = rule.find(".node-input-rule-property-value").typedInput('value');
+          r.tot = rule.find(".node-input-rule-property-value").typedInput('type');
+        }        
+        node.rules.push(r);
+      });
+
+    },
+
+    oneditresize: function(size) {
+      var rows = $("#dialog-form>div:not(.node-input-assert-values-rule-container-row)");
+      var height = size.height;
+      for (var i = 0; i < rows.length; i++) {
+        height -= $(rows[i]).outerHeight(true);
+      }
+      var editorRow = $("#dialog-form>div.node-input-assert-values-rule-container-row");
+      height -= (parseInt(editorRow.css("marginTop")) + parseInt(editorRow.css("marginBottom")));
+      height += 16;
+      $("#node-input-assert-values-rule-container").editableList('height', height);
+    },
+
+
+  });
+})();
+
+</script>
+
+<script type="text/html" data-template-name="ut-assert-values">
+  <style>
+    ol#node-input-assert-values-rule-container .red-ui-typedInput-container {
+      flex: 1;
+    }
+  </style>
+  <div class="form-row">
+    <label for="node-input-name"><i class="fa fa-tag"></i> <span data-i18n="node-red:common.label.name"></span></label>
+    <input type="text" id="node-input-name" style="width: calc(100% - 105px)"  data-i18n="[placeholder]node-red:common.label.name">
+  </div>
+  <div class="form-row" style="margin-bottom:0;">
+    <label><i class="fa fa-list"></i> <span data-i18n="ut-assert-values.label.rules"></span></label>
+  </div>
+  <div class="form-row node-input-rule-container-row node-input-assert-values-rule-container-row">
+    <ol id="node-input-assert-values-rule-container"></ol>
+  </div>
+</script>