node-red-contrib-prib-functions 0.17.0 → 0.19.2

package/matrix/matrixNode.html

@@ -0,0 +1,214 @@
+<script type="text/javascript">
+	/*globals RED */
+	RED.nodes.registerType('matrix', {
+		category: 'function',
+		color: '#fdeea2',
+		defaults: {
+			name: {value:null},
+			action: {value: "create",required:true},
+			args: {value:[]},
+			arg: {value:null},"arg-type": {value:"msg"},
+			call:{value:null},
+			column: {value:null},"column-type": {value:"num"},
+			columns: {value:null},"columns-type": {value:"num"},
+			end: {value:null},"end-type": {value:"num"},
+			factor: {value:null},"factor-type": {value:"num"},
+			matrix: {value:"payload"},"matrix-type": {value:"msg"},
+			precision: {value:3},"precision-type": {value:"num"},
+			row: {value:3},"row-type": {value:"num"},
+			rows: {value:3},"rows-type": {value:"num"},
+			rowTarget: {value:null},"rowTarget-type": {value:"num"},
+			source: {value:"_matrix"},"source-type": {value:"msg"},
+			start: {value:null},"start-type": {value:"num"},
+			target: {value:"_matrix"},"target-type": {value:"msg"},
+			value: {value:"payload"},"value-type": {value:"msg"},
+			vector: {value:"payload"},"vector-type": {value:"msg"}
+		},
+		inputs: 1,
+		outputs: 2,
+		icon: "icons8-matrix-desktop-80.png",
+		align: 'left',
+		paletteLabel: "Matrix",
+		inputLabels: "Message In",
+		outputLabels: ["Message Out","Error"],
+		label: function () {
+			return this.name || ("Matrix "+this.action||"*** new ***");
+		},
+		oneditprepare: function() {
+			const node=this;
+			node.properties=[];
+			node.editors=[];
+			const actions={
+				define:{label:"Define",show:["target"],args:["rows","columns"]},
+				defineEmpty:{label:"Define Empty",show:["target"],args:["rows","columns"]},
+				create:{label:"Create",show:["target"],args:[]},
+                createLike:{label:"Create Like",show:["source","target"],args:[]},
+                clone:{label:"Clone",show:["source","target"],args:[]},
+                add:{label:"Add",show:["source"],args:["matrix"]},
+                addRow:{label:"Add Row",show:["source"],args:["row","vector"]},
+				addRow2Row:{label:"Add Row to Row",show:["source"],args:["row","target","factor","start","end"]},
+                addCell:{label:"Add to Cell",show:["source"],args:["row","column","value"]},
+                subtractCell:{label:"Subtract Cell",show:["source","target"],args:["row","column","value"]},
+                multiple:{label:"Multiple",show:["source","target"],args:[]},
+                multipleCell:{label:"Multiple Cell",show:["source","target"],args:["rows","columns","value"]},
+                divideCell:{label:"Divide Cell",show:["source"],args:["rows","columns","value"]},
+                divideRow:{label:"Divide Row",show:["source"],args:["row","factor","start","end"]},
+                transpose:{label:"Transpose",show:["source","target"],args:[]},
+                getAdjoint:{label:"Adjoint",show:["source","target"],args:[]},
+                getCofactor:{label:"Cofactor",show:["source","target"],args:[]},
+                getComplementMinor:{label:"Complement Minor",show:["source","target"],args:[]},
+				getIdentity:{label:"Identity",show:["source","target"],args:[]},
+				getInverse:{label:"Inverse",show:["source","target"],args:[]},
+				getInverseAdjointMethod:{label:"Inverse (Adjoint Method)",show:["source","target"],args:[]},
+				getInverseGaussJordan:{label:"Inverse (Gauss Jordan Method)",show:["source","target"],args:[]},
+				norm:{label:"Norm",show:["source","target"],args:[]},
+				getDeterminant:{label:"Determinant",show:["source","target"],args:[]},
+				getDeterminantUsingCofactor:{label:"Determinant (Cofactor)",show:["source","target"],args:[]},
+				getDeterminantUsingCofactor:{label:"Determinant (Row Echelon Form)",show:["source","target"],args:[]},
+                backwardSubstitution:{label:"Backward Substitution",show:["source"],args:[]},
+				forwardElimination:{label:"Forward Elimination",show:["source"],args:[]},
+				gaussianElimination:{label:"Gaussian Elimination",show:["source"],args:[]},
+				reducedRowEchelonForm:{label:"Reduced Row EchelonForm",show:["source"],args:[]},
+				rowEchelonForm:{label:"Row Echelon Form",show:["source"],args:[]},
+                equalsNearly:{label:"Nearly Equals",show:["source"],args:[]},
+				testIsSquare:{label:"Is Square",show:["source"],args:[]},
+				get:{label:"Get Cell",show:["source","target"],args:[]},
+				sumRow:{label:"Sum Row",show:["source","target"],args:[]},
+				swapRows:{label:"Swap Rows",show:["source"],args:[]},
+				toArray:{label:"To Array Object",show:["source","target"],args:[]},
+				runningSum:{label:"Running Sum",show:["source","target"],args:[]},
+				getVandermonde:{label:"Vandermonde",show:["target"],args:["vector","columns"]},
+				create:{label:"Create",show:[,"target"],args:["rows","columns"]},
+				createForEachCellPairSet:{label:"Create Pair Set Cells",show:["source","target"],args:["matrix","call"],default:{call:"(baseCellValue,matrixCellValue)=>{}"}},
+				findRowColumn:{label:"Find in Row",show:["source"],args:["row","call","start","end"],default:{call:"(value,row,column,offset,vector)=>true"}},
+				forRowCells:{label:"Row Cells",show:["source"],args:["row","call","start","end"],default:{call:"()=>{}"}},
+				fillArray:{label:"fill",show:["source"],args:["matrix"]},
+				findColumnRow:{label:"Find in Column",show:["source"],args:["column","call","start","end"],default:{call:"()=>{}"}},
+				forColumnCells:{label:"Column Cells",show:["source"],args:["column","call","start","end"],default:{call:"()=>{}"}},
+				forEachCell:{label:"For Each Cell",show:["source"],args:["call"],default:{call:"()=>{}"}},
+				forEachRow:{label:"For Each Row",show:["source"],args:["call"],default:{call:"()=>{}"}},
+				forEachCellPairSet:{label:"For Each Cell Pair Set",show:["source"],args:["matrix","call"],default:{call:"()=>{}"}},
+				getIndex:{label:"Get Vector Offset",show:["source","target"],args:["row","column"]},
+				getZeroed:{label:"Get Zeroed",show:["source","target"],args:["row","column"]},
+				getMatrix:{label:"get Sub Matrix",show:["source","target"],args:["row","column","rows","columns"]},
+				getRow:{label:"Get Row",show:["source","target"],args:["row"]},
+				maxAbsColumn:{label:"Column Maximum Absolute",show:["source","target"],args:["column","start"]},
+				maxColumn:{label:"Column Max",show:["source","target"],args:["column","start"]},
+				multiplyRow:{label:"Multiply Row",show:["source"],args:["row","factor"]},
+				reduceRow:{label:"Reduce Row",show:["source","target"],args:["row","call","value"],default:{call:"(agregatevalue,cellValue,row,column)=>agregatevalue+cellValue"}},
+				set:{label:"Set Cell",show:["source"],args:["row","column","value"]},
+				setRow:{label:"Set Row",show:["source"],args:["vector","row"]},
+				reduce:{label:"Reduce Cells",show:["source","target"],args:["call","value"],default:{call:"()=>{}"}}
+			};
+			const baseDiv=$("#node-inputDynamicBase");
+			function defineProperty(property,...types) {
+				const element=$('<div/>',{ "class": "form-row form-row-http-in-"+property.name+" hide" }).append(
+    				 	$('<label for="node-input-'+property.name+'" style="white-space: nowrap"><i class="fa fa-'+(property.icon||'bookmark')+'"></i> '+property.label+'</label>'),
+					);
+				element.appendTo(baseDiv);
+				node.properties.push(property.name);
+				if(types[0]=="edit") {
+					element.append($('<div style="height: 250px; min-height:150px;" class="node-text-editor" id="node-input-'+property.name+'-editor"></div>'));
+					node.editors[property.name] = RED.editor.createEditor({
+   						id: 'node-input-'+property.name+'-editor',
+   						mode: 'ace/mode/'+property.mode||"text",
+   						value: node[property.name]||property.default
+					});
+				} else {
+					const inputNode=$('<input type="text" id="node-input-'+property.name+'"/>').val(node[property.name]);
+					const typeNode=$('<input type="hidden" id="node-input-'+property.name+'-type"/>');
+					element.append([inputNode,typeNode]);
+					const typeValue=node[property.name+"-type"];
+					if(typeValue) typeNode.val(typeValue);
+					$("#node-input-"+property.name).typedInput({
+	  					type:typeValue||types[0],
+    					types:types,
+    					typeField: "#node-input-"+property.name+"-type"
+					});
+				}
+			}
+			defineProperty({name:"source"	,label:"Source"		,icon:"crosshairs"},"msg","flow","global");
+			defineProperty({name:"arg"		,label:"Argument"	,icon:"tag"},"num","json","msg","flow","global","env");
+			defineProperty({name:"matrix"	,label:"Matrix"		,icon:"th"},"msg","flow","global");
+			defineProperty({name:"target"	,label:"Target"		,icon:"save"},"msg","flow","global");
+			defineProperty({name:"column"	,label:"Column"		,icon:"bars fa-rotate-90"},"num","msg","flow","global");
+			defineProperty({name:"columns"	,label:"Columns"	,icon:"bars fa-rotate-90"},"num","msg","flow","global");
+			defineProperty({name:"row"		,label:"Row"		,icon:"bars"},"num","msg","flow","global");
+			defineProperty({name:"rows"		,label:"Rows"		,icon:"bars"},"num","msg","flow","global");
+			defineProperty({name:"value"	,label:"Value"		,icon:"tachometer"},"num","msg","flow","global");
+			defineProperty({name:"rowTarget",label:"Target Row"	,icon:"bars"},"num","msg","flow","global");
+			defineProperty({name:"factor"	,label:"Factor"		,icon:"adjust"},"num","msg","flow","global");
+			defineProperty({name:"precision",label:"Precision"	,icon:"tachometer"},"num","msg","flow","global");
+			defineProperty({name:"start"	,label:"Start"		,icon:"tachometer"},"num","msg","flow","global");
+			defineProperty({name:"end"		,label:"End"		,icon:"tachometer"},"num","msg","flow","global");
+			defineProperty({name:"size"		,label:"Size"		,icon:"tachometer"},"num","msg","flow","global");
+			defineProperty({name:"vector"	,label:"Vector"		,icon:"ellipsis-h"},"json","msg","flow","global");
+			defineProperty({name:"call"		,label:"Call"		,icon:"js",mode:"javascript"},"edit");
+
+			const options=Object.keys(actions).reduce((previousValue,property)=>previousValue.concat({value:property,label:actions[property].label}),
+				[]);
+			const actionNode=$("#node-input-action");
+			actionNode.typedInput({
+    			types: [{
+            		value: "actionType",
+            		options: options
+				}]
+			});
+	actionNode.change(function() {
+				action=$(this).val();
+				node.args=[];
+				node.properties.forEach(property=>$(".form-row-http-in-"+property).hide());
+				const actionDef=actions[action];
+				node.args=actionDef.args;
+				node.args.forEach(property=>$(".form-row-http-in-"+property).show());
+				actionDef.show.forEach(property=>$(".form-row-http-in-"+property).show());
+
+			});
+		},
+		oneditsave: function() {
+			const node=this;
+			Object.keys(node.editors).forEach(property=>{
+				const editor=node.editors[property];
+				node[property]=editor.getValue();
+	    		editor.destroy();
+    			delete editor;
+			})
+		},
+		oneditcancel: function() {
+			const node=this;
+			Object.keys(node.editors).forEach(property=>{
+				const editor=node.editors[property];
+    			editor.destroy();
+    			delete editor;
+			});
+		},
+		resizeRule: function(file,newWidth) {
+		}
+	});
+</script>
+
+<script type="text/x-red" data-template-name="matrix">
+
+	<div class="form-row">
+		<label for="node-input-name"><i class="fa fa-tag"></i> Name </label>
+		<input type="text" id="node-input-name" placeholder="Name">
+	</div>
+	<div class="form-row">
+		<label for="node-input-action" style="white-space: nowrap"><i class="fa fa-cog"></i> Action</label>
+		<input type="text" id="node-input-action">
+    </div>
+	<div id="node-inputDynamicBase"/>
+</script>
+
+<script type="text/x-red" data-help-name="matrix">
+	<p>
+	Matrix manipulation
+	</p>
+	<h3>Inputs</h3>
+	<dl class="message-properties">
+		<dt>msg <span class="property-type">topic</span></dt>
+		<dd>incoming message with topic</dd>
+		<dt>msg <span class="property-type">payload</span></dt>
+		<dd></dd>
+	</dl>
+</script>

package/matrix/matrixNode.js

@@ -0,0 +1,162 @@
+const logger = new (require("node-red-contrib-logger"))("matrix");
+logger.sendInfo("Copyright 2022 Jaroslav Peter Prib");
+const Matrix = require("./matrix");
+function error(node,message,shortMessage){
+	if(logger.active) logger.send({label:"error",node:node.id,error:error,shortMessage});
+	node.error(message);
+	node.status({fill:"red",shape:"ring",text:shortMessage});
+}
+function evalFunction(id,mapping){
+	logger.sendInfo({label:"evalFunction",id:id,mapping:mapping})
+	try{
+		return eval(mapping);
+	} catch(ex) {
+		logger.sendError({label:"evalFunction error",id:id,mapping:mapping,error:ex.message})
+		throw Error(id+" "+ex.message);
+	}
+}
+function evalInFunction(node,propertyName){
+	try{
+	    const nodeContext = node.context();
+		const flow = nodeContext.flow;
+		const global = nodeContext.global;
+		const property=node[propertyName];
+		if(property==null) throw Error("no value for "+propertyName);
+		const propertyType=propertyName+"-type";
+		switch (node[propertyType]){
+		case "num":
+		case "json":
+			return evalFunction(propertyName,"()=>"+property);
+		case "node":
+			return evalFunction(propertyName,"()=>nodeContext.get("+property+")");
+		case "flow":
+			if(flow) throw Error("context store may be memoryonly so flow doesn't work")
+			return evalFunction(propertyName,"()=>flow.get("+property+")");
+		case "global":
+			return evalFunction(propertyName,"()=>global.get("+property+")");
+		case "env":
+			return evalFunction(propertyName,"()=>env.get("+property+")");
+		case "msg":
+			return evalFunction(propertyName,"(msg)=>msg."+property);
+		default:
+			logger.sendInfo({label:"setData unknown type",action:node.action,propertyType:propertyType,type:node[propertyType]});
+			throw Error("unknown type "+node[propertyType])
+		}
+	} catch(ex) {
+		logger.sendError({label:"setup",error:ex.message,stack:ex.stack});
+		throw Error(property+" "+ex.message);
+	}
+}
+function argsArray(node,msg) {
+	const args=[];
+	node.argFunction.forEach(callFunction=> {
+		const result=callFunction(msg);
+		args.push(result);
+	});
+	return args;
+}
+module.exports = function (RED) {
+	function matrixNode(n) {
+	    RED.nodes.createNode(this,n);
+//		logger.sendInfo({label:"create",node:n});
+	    const node=Object.assign(this,n);
+		try{
+			if(node.source)node.getSource=evalInFunction(node,"source");
+			if(node.target) {
+				const nodeContext = node.context();
+				const flow = nodeContext.flow;
+				const global = nodeContext.global;
+				switch(node["target-type"]){
+				case "node":
+					node.setData=evalFunction("target","data=>nodeContext.set("+node.target+",data)");
+					break;
+				case "flow":
+					if(flow) throw Error("context store may be memoryonly so flow doesn't work")
+					node.setData=evalFunction("target","data=>flow.set("+node.target+",data)");
+					break;
+				case "global":
+					node.setData=evalFunction("target","data=>global.set("+node.target+",data)");
+					break;
+				case "msg":
+					node.setData=evalFunction("target","(data,msg)=>{msg."+node.target+"=data;}");
+					break;
+				default:
+					logger.sendInfo({label:"setData unknown type",action:node.action,targetType:node["target-type"]});
+				}
+			}	
+			node.argFunction=[];
+			node.args.forEach(property=>{
+				node.argFunction.push(evalInFunction(node,property).bind(this));
+			})
+			function baseProcess(msg){
+				const sourceIn=node.getSource(msg);
+				if(sourceIn==null) throw Error("source data not found");
+				const sourceMatrix=(sourceIn instanceof Matrix?sourceIn:new Matrix(sourceIn));
+				return sourceMatrix[node.action].apply(sourceMatrix,argsArray(node,msg));
+			}
+			function baseProcessAndSet(msg){
+				const result=baseProcess(msg);
+				node.setData.apply(node,[result,msg]);
+			}
+			function createProcess(msg){
+				const sourceIn=node.getSource(msg);
+				if(sourceIn==null) throw Error("source data not found");
+				const sourceMatrix=(sourceIn instanceof Matrix?sourceIn.clone():new Matrix(sourceIn));
+				node.setData.apply(node,[sourceMatrix,msg]);
+			}
+			function defineProcess(msg){
+				if(logger.active) logger.sendInfo({label:"define",arg:{rows:node.row,columns:node.column}});
+				const sourceMatrix=new Matrix({rows:node.rows,columns:node.columns});
+				node.setData.apply(node,[sourceMatrix,msg]);
+			}
+			function defineEmptyProcess(msg){
+				if(logger.active) logger.sendInfo({label:"define",arg:{rowsMax:node.row,columns:node.column}});
+				const sourceMatrix=new Matrix({rowsMax:node.rows,columns:node.columns});
+				node.setData.apply(node,[sourceMatrix,msg]);
+			}
+			function createSize(msg){
+				const sourceMatrix=new Matrix({rows:node.size,columns:node.size});
+				node.setData.apply(node,[sourceMatrix[node.action](),msg]);
+			}
+			function createDummy(msg){
+				const sourceMatrix=new Matrix(1,1);
+				node.setData.apply(node,[sourceMatrix[node.action].apply(sourceMatrix,argsArray(node,msg)),msg]);
+			}
+			node.msgProcess=baseProcess;
+			if(["define"].includes(node.action)){
+				node.msgProcess=defineProcess;
+			}else if(["defineEmpty"].includes(node.action)){
+				node.msgProcess=defineEmptyProcess;
+			}else if(["create"].includes(node.action)){
+				node.msgProcess=createProcess;
+			}else if(["runningSum"].includes(node.action)){
+				node.msgProcess=createSize;
+			}else if(["getVandermonde"].includes(node.action)){
+				node.msgProcess=createDummy;
+			}else{
+				if(node.action.startsWith("get") 
+				|| ["create","createLike","clone","transpose","sumRow","createForEachCellPairSet",
+					,"findRowColumn","findColumnRow","maxAbsColumn","maxColumn","toArray"
+				].includes(node.action)) {
+					node.msgProcess=baseProcessAndSet;
+				}
+			}
+		} catch(ex) {
+			logger.sendError({label:"setup",error:ex.message,stack:ex.stack})
+			error(node,ex,"Invalid setup "+ex.message);
+			return;
+		}
+		node.status({fill:"green",shape:"ring"});
+		node.on("input",function (msg) {
+			try{
+				node.msgProcess(msg);
+				node.send(msg);
+			} catch(ex) {
+				msg.error=ex.message;
+				node.send([null,msg]);
+				if(logger.active) logger.send({label:"error",node:node.id,action:node.action,exception:ex.message,stack:ex.stack});
+			}
+		});
+	}
+	RED.nodes.registerType(logger.label, matrixNode);
+};

package/package.json

@@ -1,11 +1,13 @@
 {
 	"name": "node-red-contrib-prib-functions",
-	"version": "0.17.0",
+	"version": "0.19.2",
 	"description": "Node-RED added node functions.",
 	"dependencies": {
 		"avsc": "^5.6.1",
+		"compressiontool": "*",
 		"fast-xml-parser": "^3.19.0",
-		"node-red-contrib-logger": "^0.0.6",
+		"node-red-contrib-logger": "latest",
+		"node-red-contrib-noderedbase": ">=0.0.16",
 		"xlsx": "^0.17.0"
 	},
 	"devDependencies": {
@@ -14,11 +16,12 @@
 		"bcrypt": "^5.0.1",
 		"bl": "^5.0.0",
 		"mocha": "^9.2.2",
-		"node-red": "^2.2.2",
-		"node-red-node-test-helper": "^0.2.7"
+		"node-red": "^3.0.2",
+		"node-red-node-test-helper": "^0.3.0"
 	},
 	"scripts": {
-		"test": "mocha \"test/**/e*.js\""
+		"test": "mocha \"test/matrix/**/*.js\"",
+		"startNodeRed": "pwd; node-red --title '***test nodered***' --setting ./test/data/settings.js ./test/data/flow.json"
 	},
 	"repository": {
 		"type": "git",
@@ -26,32 +29,49 @@
 	},
 	"keywords": [
 		"node-red",
+		"adjoint",
 		"append",
 		"analysis",
 		"average",
 		"avg",
 		"AVRO",
 		"arvo",
+		"backward substitution",
 		"compare",
+		"Complement Minor",
+		"compression",
 		"CMA",
 		"cumulative",
 		"Cumulative Moving Average",
 		"data",
 		"data analysis",
+		"decompression",
+		"deflate",
 		"delta",
+		"determinant",
 		"distance",
 		"euclidian distance",
 		"EMA",
 		"EWMA",
 		"Exponential Moving Average",
+		"forward elimination",
 		"functions",
-		"injector",
+		"gauss jordan",
+		"Gauss Jordan Inverse",
+		"gaussian elimination",
+		"gzip",
 		"host available",
 		"host status",
+		"identity",
+		"inflate",
+		"injector",
+		"inverse",
+		"inverse matrix",
 		"Linear Correlation Coefficient",
 		"levenshtein distance",
 		"load",
 		"load injector",
+		"matrix",
 		"maximum",
 		"mean",
 		"median",
@@ -66,6 +86,8 @@
 		"Process",
 		"range",
 		"realtime",
+		"Reduced Row Echelon Form",
+		"Row Echelon Form",
 		"sample variance",
 		"sample stddev",
 		"Simple Moving Average",
@@ -82,6 +104,8 @@
 		"test",
 		"translate",
 		"transform",
+		"transpose",
+		"unzip",
 		"variance",
 		"weighted",
 		"Weighted Moving Average",
@@ -91,15 +115,18 @@
 		"xcel",
 		"xml",
 		"XML",
+		"zip",
 		"Z-score"
 	],
 	"node-red": {
+		"version": ">=2.0.0",
 		"nodes": {
 			"append": "append/append.js",
 			"dataAnalysis": "dataAnalysis/dataAnalysis.js",
 			"hostAvailable": "testing/hostAvailable.js",
 			"levenshteinDistance": "levenshteinDistance/levenshteinDistanceNode.js",
 			"load-injector": "testing/load-injector.js",
+			"matrix": "matrix/matrixNode.js",
 			"monitorflow": "monitor/monitorflow.js",
 			"os": "nodejs/os.js",
 			"spawnProcess": "spawnProcess/spawnProcess.js",

package/test/01-base.js

@@ -0,0 +1,88 @@
+const assert=require('assert');
+const should=require("should");
+const helper=require("node-red-node-test-helper");
+const storageDefinition=require("../nodes/storageDefinition.js");
+const storageRead = require('../nodes/storageRead.js');
+
+helper.init(require.resolve('node-red'));
+
+function getAndTestNodeProperties(o) {
+	const n = helper.getNode(o.id);
+	for(let p in o) n.should.have.property(p, o[p]);
+	return n;
+}
+
+const blockStorage={
+	id : "blockStorage",
+	type : "Storage Definition",
+	name : "Block Storage",
+	action: "blockStorage",
+	sourceProperty:"blockStorageFile",
+	blockSize:4096
+};
+
+const StorageReadBlock={
+	id : "StorageReadBlockid",
+	type : "Storage Read",
+	name : "Block Storage",
+	target:"payload",
+	"target-type":"msg",
+	key:"topic"
+};
+
+function testFlow(done,node,data,result) {
+	const flow = [
+		Object.assign(node,{wires : [ [ "outHelper" ],["errorHelper"] ]}),
+		{id :"outHelper",	type : "helper"},
+		{id :"errorHelper",	type : "helper"}
+	];
+	helper.load(storageDefinition, flow, function() {
+		const n=getAndTestNodeProperties(node);
+		const outHelper = helper.getNode("outHelper");
+		const errorHelper = helper.getNode("errorHelper");
+		outHelper.on("input", function(msg) {
+			console.log("outHelper "+JSON.stringify(msg.payload));
+			if(JSON.stringify(msg.payload)==JSON.stringify(result)) {
+				done();
+			} else {
+				console.log("mismatch  expected: "+JSON.stringify(result) +" returned: "+JSON.stringify(msg.payload));
+				done("mismatch");
+			}
+		});
+		errorHelper.on("input", function(msg) {
+			console.log("errorHelper "+JSON.stringify(msg));
+			done("error  check log output");
+		});
+		n.receive({
+			topic:"test",
+			payload : data
+		});
+	});
+}
+
+describe('Storage Defintion', function() {
+	beforeEach(function(done) {
+		helper.startServer(done);
+	});
+	afterEach(function(done) {
+		helper.unload();
+		helper.stopServer(done);
+	});
+	it("load config", function(done) {
+		helper.load(storageDefinition,[], function() {
+			const n=getAndTestNodeProperties(storageDefinition);
+		});
+		done();
+	});
+	it("load read", function(done) {
+		helper.load(storageDefinition,storageRead,[], function() {
+			const n=getAndTestNodeProperties(storageDefinition);
+		});
+		done();
+	});
+	
+	it('read 1', function(done) {
+		const msg={topic:1}
+		testFlow(done,storageDefinition,msg,msg);
+	});
+});