nodbus-plus 0.8.2 → 1.0.0

package/test/nodbus_client_serial.test.js

@@ -0,0 +1,307 @@
+const Nodbus = require('../src/nodbus-plus');
+
+//creating config file for basic server 1
+let serverCfg = {
+    inputs : 524,
+    coils : 0,
+    holdingRegisters : 512,
+    inputRegisters : 256,      
+    udpType : 'udp6', 
+    port : 520
+}
+
+//creating config file for basic server 1
+let serverCfg2 = {
+    transmitionMode : 1,
+    inputs : 524,
+    coils : 0,
+    holdingRegisters : 512,
+    inputRegisters : 256,      
+    udpType : 'udp4', 
+    port : 522
+}
+
+describe("rtu client", () => {
+
+    let server1 = Nodbus.createSerialServer('tcp', serverCfg);
+      
+    let client = Nodbus.createSerialClient();
+    client.addChannel('server1', 'tcp1', {ip:'127.0.0.1', port: 520})
+    expect(client.isChannelReady('server1')).toEqual(false);
+
+    test("functions", (done) => {
+
+        expect(server1.isListening).toEqual(false);           
+
+        
+
+        client.on('transaction', (req, res) =>{
+            let reqAddress = req[0];
+            let resAddress = res[0];           
+            let functionCode = req[1];
+            let valBuffer  = Buffer.alloc(2);
+            
+            expect(reqAddress).toEqual(resAddress)
+            expect(resAddress).toEqual(1)
+           
+            switch(functionCode){
+                case 0x01:                    
+                    expect(res.length).toEqual(6)
+                    client.readInputs('server1', 1, 0, 2);                                        
+                    break;
+                case 0x02:
+                    expect(res.length).toEqual(6)
+                    client.readHoldingRegisters('server1', 1, 0, 2);                 
+                    break
+                case 0x03:
+                    expect(res.length).toEqual(9)
+                    client.readInputRegisters('server1', 1, 0, 2);                    
+                    break
+                case 0x04:
+                    expect(res.length).toEqual(9)
+                    client.forceSingleCoil(true, 'server1', 1, 5);
+                    break;
+                case 0x05:
+                    expect(res.length).toEqual(8)
+                    expect(res[4]).toEqual(0xFF);                    
+                    valBuffer[1] = 0x45;
+                    client.presetSingleRegister(valBuffer, 'server1', 1, 10);                    
+                    break;
+                case 0x06:
+                    expect(res.length).toEqual(8)
+                    expect(res[3]).toEqual(10);
+                    expect(res[5]).toEqual(0x45);
+                    let coils = [1, 1, 0, 0 , 1, 0, 0, 0, 1, 1, 1, 0];
+                    client.forceMultipleCoils(coils, 'server1', 1, 12); 
+                    break
+                case 0x0f:
+                    expect(res.length).toEqual(8)
+                    expect(res[5]).toEqual(12);
+                    valBuffer = Buffer.alloc(5);
+                    let tempRegister = Buffer.alloc(2);
+                    tempRegister.writeUint16BE(123);
+                    client.setWordToBuffer(tempRegister, valBuffer, 0);
+                    tempRegister.writeUint16BE(1234);
+                    client.setWordToBuffer(tempRegister, valBuffer, 1);
+                    client.presetMultiplesRegisters(valBuffer, 'server1', 1, 20);
+                    break;
+                case 0x10:
+                    expect(res.length).toEqual(8)                   
+                    expect(res[5]).toEqual(2);
+                    registerMask = [1, 0, 2, 0, 0, 1, 1, 1, 2, 2, 2, 0, 1, 2, 2, 1];
+                    client.maskHoldingRegister(registerMask, 'server1', 1, 22);   
+                    break;
+                case 0x16:
+                    expect(res.length).toEqual(10)                   
+                    expect(res[3]).toEqual(req[3]);
+                    expect(res[5]).toEqual(req[5]);
+                    expect(res[7]).toEqual(req[7]);
+                    client.readWriteMultiplesRegisters(valBuffer, 'server1', 1, 10, 3, 20);
+                    break
+                case 0x17:
+                    expect(res.length).toEqual(11)                   
+                    expect(res[2]).toEqual(6);                    
+                    client.presetSingleRegister(valBuffer, 'server1', 0, 10); 
+                    break;
+                default:
+                    client.disconnect('server1');
+            }
+
+           
+        })
+
+        client.on('broadcast-timeout', () =>{
+            //console.log('broadcast timeout')
+            client.disconnect('server1');
+        })
+
+        client.on('connection-closed', ()=>{
+            //console.log('stopping server')
+            server1.stop()
+        })
+
+        client.on('connection', (id)=>{
+            //console.log('client connected')
+            let channel = client.channels.get(id);
+            expect(id).toEqual('server1');                 
+            expect(channel.ip).toEqual('127.0.0.1');
+            expect(channel.port).toEqual(520);
+            expect(client.isChannelReady(id)).toEqual(true);
+            
+            client.readCoils('server1', 1, 0, 2);            
+            
+        })
+
+        server1.on('listening', (port)=>{
+            //console.log('server listenning')
+            let connectPromise = client.connect('server1');
+        });
+        
+        server1.on('connection-closed', (has_error) => {
+           // console.log('client disconnected')
+        })
+
+        server1.on('closed', ()=>{
+            expect(server1.isListening).toEqual(false);
+            done()
+        })
+
+        server1.on('connection', (sock)=>{
+            //console.log('server say connection')
+        })
+
+        server1.on('data', (sock, data) => {
+            //console.log(data)
+        })
+
+        server1.start(); 
+
+        
+
+    });    
+    
+    
+});
+
+describe("ascii client", () => {
+
+    let server2 = Nodbus.createSerialServer('tcp', serverCfg2);
+      
+    let client = Nodbus.createSerialClient();
+    client.addChannel('server2', 'tcp1', {ip:'127.0.0.1', port: 522})
+    expect(client.isChannelReady('server2')).toEqual(false);
+
+    test("functions", (done) => {
+
+        expect(server2.isListening).toEqual(false);           
+
+        
+
+        client.on('transaction', (req, res) =>{
+            let reqAddress = req[0];
+            let resAddress = res[0];           
+            let functionCode = req[1];
+            let valBuffer  = Buffer.alloc(2);
+            
+            expect(reqAddress).toEqual(resAddress)
+            
+           
+            switch(functionCode){
+                case 0x01:                    
+                    expect(res.length).toEqual(6)
+                    client.readInputs('server2', 1, 0, 2, true);                                        
+                    break;
+                case 0x02:
+                    expect(res.length).toEqual(6)
+                    client.readHoldingRegisters('server2', 1, 0, 2, true);                 
+                    break
+                case 0x03:
+                    expect(res.length).toEqual(9)
+                    client.readInputRegisters('server2', 1, 0, 2, true);                    
+                    break
+                case 0x04:
+                    expect(res.length).toEqual(9)
+                    client.forceSingleCoil(true, 'server2', 1, 5, true);
+                    break;
+                case 0x05:
+                    expect(res.length).toEqual(8)
+                    expect(res[4]).toEqual(0xFF);                    
+                    valBuffer[1] = 0x45;
+                    client.presetSingleRegister(valBuffer, 'server2', 1, 10, true);                    
+                    break;
+                case 0x06:
+                    expect(res.length).toEqual(8)
+                    expect(res[3]).toEqual(10);
+                    expect(res[5]).toEqual(0x45);
+                    let coils = [1, 1, 0, 0 , 1, 0, 0, 0, 1, 1, 1, 0];
+                    client.forceMultipleCoils(coils, 'server2', 1, 12, true); 
+                    break
+                case 0x0f:
+                    expect(res.length).toEqual(8)
+                    expect(res[5]).toEqual(12);
+                    valBuffer = Buffer.alloc(5);
+                    let tempRegister = Buffer.alloc(2);
+                    tempRegister.writeUint16BE(123);
+                    client.setWordToBuffer(tempRegister, valBuffer, 0);
+                    tempRegister.writeUint16BE(1234);
+                    client.setWordToBuffer(tempRegister, valBuffer, 1);
+                    client.presetMultiplesRegisters(valBuffer, 'server2', 1, 20, true);
+                    break;
+                case 0x10:
+                    expect(res.length).toEqual(8)                   
+                    expect(res[5]).toEqual(2);
+                    registerMask = [1, 0, 2, 0, 0, 1, 1, 1, 2, 2, 2, 0, 1, 2, 2, 1];
+                    client.maskHoldingRegister(registerMask, 'server2', 1, 22, true);   
+                    break;
+                case 0x16:
+                    expect(res.length).toEqual(10)                   
+                    expect(res[3]).toEqual(req[3]);
+                    expect(res[5]).toEqual(req[5]);
+                    expect(res[7]).toEqual(req[7]);
+                    client.readWriteMultiplesRegisters(valBuffer, 'server2', 1, 10, 3, 20, true);
+                    break
+                case 0x17:
+                    expect(res.length).toEqual(11)                   
+                    expect(res[2]).toEqual(6);                    
+                    client.disconnect('server2');
+                    break;
+                default:
+                    client.disconnect('server2');
+            }
+
+           
+        })
+
+        client.on('connection-closed', ()=>{
+            //console.log('stopping server')
+            server2.stop()
+        })
+
+        client.on('connection', (id)=>{
+            //console.log('client connected')
+            let channel = client.channels.get(id);
+            expect(id).toEqual('server2');                 
+            expect(channel.ip).toEqual('127.0.0.1');
+            expect(channel.port).toEqual(522);
+            expect(client.isChannelReady(id)).toEqual(true);
+            
+            client.readCoils('server2', 1, 0, 2, true);
+            
+            
+        })
+
+        server2.on('listening', (port)=>{
+            //console.log('server listenning')
+            let connectPromise = client.connect('server2');
+        });
+        
+        server2.on('connection-closed', (has_error) => {
+           // console.log('client disconnected')
+        })
+
+        server2.on('closed', ()=>{
+            expect(server2.isListening).toEqual(false);
+            done()
+        })
+
+        server2.on('connection', (sock)=>{
+            //console.log('server say connection')
+        })
+
+        server2.on('data', (sock, data) => {
+           // console.log(data)
+        })
+
+        server2.on('write', (sock, data)=>{
+           // console.log(data)
+        })
+
+        server2.start(); 
+
+        
+
+    });    
+    
+    
+});
+

package/test/nodbus_client_tcp.test.js

@@ -0,0 +1,334 @@
+
+const Nodbus = require('../src/nodbus-plus');
+
+//creating config file for basic server 1
+let serverCfg = {
+    inputs : 524,
+    coils : 0,
+    holdingRegisters : 512,
+    inputRegisters : 256,      
+    udpType : 'udp6', 
+    port : 510
+}
+
+//creating config file for basic server 1
+let serverCfg2 = {
+    inputs : 524,
+    coils : 0,
+    holdingRegisters : 512,
+    inputRegisters : 256,      
+    udpType : 'udp4', 
+    port : 512
+}
+
+describe("tcp client", () => {
+
+    let server1 = Nodbus.createTcpServer('tcp', serverCfg);
+      
+    let client = Nodbus.createTcpClient();
+    client.addChannel('server1', 'tcp1', {ip:'127.0.0.1', port: 510})
+    expect(client.isChannelReady('server1')).toEqual(false);
+
+    test("functions", (done) => {
+
+        expect(server1.isListening).toEqual(false);           
+
+        let tCounter = 0;  //used to count response.
+
+        client.on('transaction', (req, res) =>{
+            let reqId = req.readUInt16BE(0);
+            let resId = res.readUInt16BE(0);
+            let unitId = req[6]
+            let functionCode = req[7];
+            
+            expect(reqId).toEqual(resId)
+            expect(unitId).toEqual(255)
+           
+            switch(functionCode){
+                case 0x01:                    
+                    expect(res.length).toEqual(10)
+                    tCounter++;                    
+                    break;
+                case 0x02:
+                    expect(res.length).toEqual(10)
+                    tCounter++;                    
+                    break
+                case 0x03:
+                    expect(res.length).toEqual(13)
+                    tCounter++;                    
+                    break
+                case 0x04:
+                    expect(res.length).toEqual(13)
+                    tCounter++;
+                    break;
+                case 0x05:
+                    expect(res.length).toEqual(12)
+                    expect(res[10]).toEqual(0xFF);
+                    tCounter++;
+                    break;
+                case 0x06:
+                    expect(res.length).toEqual(12)
+                    expect(res[9]).toEqual(10);
+                    expect(res[11]).toEqual(0x45);
+                    tCounter++;   
+                    break
+                case 0x0f:
+                    expect(res.length).toEqual(12)
+                    expect(res[11]).toEqual(12);
+                    tCounter++;
+                    break;
+                case 0x10:
+                    expect(res.length).toEqual(12)                   
+                    expect(res[11]).toEqual(2);
+                    tCounter++;   
+                    break;
+                case 0x16:
+                    expect(res.length).toEqual(14)                   
+                    expect(res[9]).toEqual(req[9]);
+                    expect(res[11]).toEqual(req[11]);
+                    expect(res[13]).toEqual(req[13]);
+                    tCounter++;
+                    break
+                case 0x17:
+                    expect(res.length).toEqual(15)                   
+                    expect(res[8]).toEqual(6);
+                    tCounter++;                    
+                    expect(tCounter).toEqual(10);
+                    client.disconnect('server1');
+                    break;
+                default:
+                    client.disconnect('server1');
+            }
+
+           
+        })
+
+        client.on('connection-closed', ()=>{
+            //console.log('stopping server')
+            server1.stop()
+        })
+
+        client.on('connection', (id)=>{
+            //console.log('client connected')
+            let channel = client.channels.get(id);
+            expect(id).toEqual('server1');                 
+            expect(channel.ip).toEqual('127.0.0.1');
+            expect(channel.port).toEqual(510);
+            expect(client.isChannelReady(id)).toEqual(true);
+
+            client.readCoils('server1', 255, 0, 2);
+            client.readInputs('server1', 255, 0, 2);
+            client.readHoldingRegisters('server1', 255, 0, 2);
+            client.readInputRegisters('server1', 255, 0, 2);
+            client.forceSingleCoil(true, 'server1', 255, 5);
+            let valBuffer  = Buffer.alloc(2);
+            valBuffer[1] = 0x45;
+            client.presetSingleRegister(valBuffer, 'server1', 255, 10);
+            let coils = [1, 1, 0, 0 , 1, 0, 0, 0, 1, 1, 1, 0];
+            client.forceMultipleCoils(coils, 'server1', 255, 12);
+            valBuffer = Buffer.alloc(5);
+            let tempRegister = Buffer.alloc(2);
+            tempRegister.writeUint16BE(123);
+            client.setWordToBuffer(tempRegister, valBuffer, 0);
+            tempRegister.writeUint16BE(1234);
+            client.setWordToBuffer(tempRegister, valBuffer, 1);
+            client.presetMultiplesRegisters(valBuffer, 'server1', 255, 20);
+            registerMask = [1, 0, 2, 0, 0, 1, 1, 1, 2, 2, 2, 0, 1, 2, 2, 1];
+            client.maskHoldingRegister(registerMask, 'server1', 255, 22);
+            client.readWriteMultiplesRegisters(valBuffer, 'server1', 255, 10, 3, 20);
+
+           
+            
+        })
+
+        server1.on('listening', (port)=>{
+            //console.log('server listenning')
+            let connectPromise = client.connect('server1');
+        });
+        
+        server1.on('connection-closed', (has_error) => {
+           // console.log('client disconnected')
+        })
+
+        server1.on('closed', ()=>{
+            expect(server1.isListening).toEqual(false);
+            done()
+        })
+
+        server1.on('connection', (sock)=>{
+            //console.log('server say connection')
+        })
+
+        server1.on('data', (sock, data) => {
+            //console.log(data)
+        })
+
+        server1.start(); 
+
+        
+
+    });    
+    
+    
+});
+
+describe("udp client", () => {
+
+    let server2 = Nodbus.createTcpServer('udp4', serverCfg2);
+      
+    let client2 = Nodbus.createTcpClient();
+
+    client2.addChannel('server2', 'udp1', {ip:'127.0.0.1', port: 512, udpType:'udp4',})
+
+    expect(client2.isChannelReady('server2')).toEqual(false);
+
+    test("functions", (done) => {
+
+        expect(server2.isListening).toEqual(false);           
+
+        let tCounter = 0;  //used to count response.
+
+        client2.on('transaction', (req, res) =>{
+            let reqId = req.readUInt16BE(0);
+            let resId = res.readUInt16BE(0);
+            let unitId = req[6]
+            let functionCode = req[7];
+            
+            expect(reqId).toEqual(resId)
+            expect(unitId).toEqual(255)
+           
+            switch(functionCode){
+                case 0x01:                    
+                    expect(res.length).toEqual(10)
+                    tCounter++;                    
+                    break;
+                case 0x02:
+                    expect(res.length).toEqual(10)
+                    tCounter++;                    
+                    break
+                case 0x03:
+                    expect(res.length).toEqual(13)
+                    tCounter++;                    
+                    break
+                case 0x04:
+                    expect(res.length).toEqual(13)
+                    tCounter++;
+                    break;
+                case 0x05:
+                    expect(res.length).toEqual(12)
+                    expect(res[10]).toEqual(0xFF);
+                    tCounter++;
+                    break;
+                case 0x06:
+                    expect(res.length).toEqual(12)
+                    expect(res[9]).toEqual(10);
+                    expect(res[11]).toEqual(0x45);
+                    tCounter++;   
+                    break
+                case 0x0f:
+                    expect(res.length).toEqual(12)
+                    expect(res[11]).toEqual(12);
+                    tCounter++;
+                    break;
+                case 0x10:
+                    expect(res.length).toEqual(12)                   
+                    expect(res[11]).toEqual(2);
+                    tCounter++;   
+                    break;
+                case 0x16:
+                    expect(res.length).toEqual(14)                   
+                    expect(res[9]).toEqual(req[9]);
+                    expect(res[11]).toEqual(req[11]);
+                    expect(res[13]).toEqual(req[13]);
+                    tCounter++;
+                    break
+                case 0x17:
+                    expect(res.length).toEqual(15)                   
+                    expect(res[8]).toEqual(6);
+                    tCounter++;                    
+                    expect(tCounter).toEqual(10);
+                    client2.disconnect('server2');
+                    break;
+                default:
+                    client2.disconnect('server2');
+            }
+
+           
+        })
+
+        client2.on('connection-closed', ()=>{
+            //console.log('stopping server')
+            server2.stop()
+        })
+
+        client2.on('connection', (id)=>{
+            //console.log('client connected')
+            let channel = client2.channels.get(id);
+            expect(id).toEqual('server2');                 
+            expect(channel.ip).toEqual('127.0.0.1');
+            expect(channel.port).toEqual(512);
+            expect(client2.isChannelReady(id)).toEqual(true);            
+            client2.readCoils('server2', 255, 0, 2);
+            client2.readInputs('server2', 255, 0, 2);
+            client2.readHoldingRegisters('server2', 255, 0, 2);
+            client2.readInputRegisters('server2', 255, 0, 2);
+            client2.forceSingleCoil(true, 'server2', 255, 5);            
+            let valBuffer  = Buffer.alloc(2);
+            valBuffer[1] = 0x45;
+            client2.presetSingleRegister(valBuffer, 'server2', 255, 10);
+            let coils = [1, 1, 0, 0 , 1, 0, 0, 0, 1, 1, 1, 0];
+            client2.forceMultipleCoils(coils, 'server2', 255, 12);
+            valBuffer = Buffer.alloc(5);
+            let tempRegister = Buffer.alloc(2);
+            tempRegister.writeUint16BE(123);
+            client2.setWordToBuffer(tempRegister, valBuffer, 0);            
+            tempRegister.writeUint16BE(1234);
+            client2.setWordToBuffer(tempRegister, valBuffer, 1);
+            client2.presetMultiplesRegisters(valBuffer, 'server2', 255, 20);
+            registerMask = [1, 0, 2, 0, 0, 1, 1, 1, 2, 2, 2, 0, 1, 2, 2, 1];
+            client2.maskHoldingRegister(registerMask, 'server2', 255, 22);
+            client2.readWriteMultiplesRegisters(valBuffer, 'server2', 255, 10, 3, 20);
+                       
+            
+        })
+
+        client2.on('write', (id, req) =>{
+            //console.log(req)
+        })
+
+        server2.on('listening', (port)=>{
+            //console.log('server listenning')
+            client2.connect('server2');            
+        });
+        
+        server2.on('connection-closed', (has_error) => {
+           // console.log('client disconnected')
+        })
+        
+        server2.on('closed', ()=>{
+            //console.log('server closed')
+            expect(server2.isListening).toEqual(false);
+            let channel = client2.channels.get('server2');
+            channel.coreChannel.close();
+            setTimeout(()=>{                
+                done();
+            }, 250)
+            
+        })
+        
+        server2.on('connection', (sock)=>{
+            //console.log('server say connection')
+        })
+
+        server2.on('data', (sock, data) => {
+            //console.log(data)
+        })
+
+        server2.start();
+        
+        
+
+    });    
+    
+    
+});