@schukai/monster 3.1.2 → 3.3.0

package/test/cases/data/datasource/websocket.mjs

@@ -24,16 +24,22 @@ describe('Websocket', function () {
         if (ds) {
             ds.close()
         }
-        
-        // without this, the node test will hang 
+
+        // workaround: without this, the node test will hang 
         for (const sym of Object.getOwnPropertySymbols(ds)) {
-            if (sym.toString() ==='Symbol(connection)') {
-                if(ds[sym]?.socket?.['terminate']) {
-                    ds[sym]?.socket?.['terminate']()
+            if (sym.toString() === 'Symbol(connection)') {
+                const connection = ds[sym]
+                for (const sym2 of Object.getOwnPropertySymbols(connection)) {
+                    if (sym2.toString() === 'Symbol(connection)') {
+                        const socket = connection[sym2]?.socket;
+                        if (socket) {
+                            socket.terminate()
+                        }
+                    }
                 }
             }
         }
-        
+
         done()
     });
 
@@ -41,12 +47,90 @@ describe('Websocket', function () {
 
         ds = new WebSocketDatasource(testUrl)
         const clone = ds.getClone()
-        
+
         expect(clone).to.be.an.instanceof(WebSocketDatasource)
 
-        
+
+    })
+
+    it('should transform data', function (done) {
+
+        let writeCallbackCalled = false
+        let readCallbackCalled = false
+
+        ds = new WebSocketDatasource({
+            url: testUrl,
+            write: {
+                mapping: {
+                    transformer: "call:onWrite",
+                    callbacks: {
+                        onWrite: (data) => {
+                            writeCallbackCalled = true
+                            return data
+                        }
+                    }
+                },
+                sheathing: {
+                    object: {
+                        demo: 1,
+                        data: {
+                            xyz: undefined
+                        }
+                    },
+                    path: "data.xyz",
+                },
+            },
+            read: {
+                mapping: {
+                    transformer: "call:onRead",
+                    callbacks: {
+                        onRead: (data) => {
+                            readCallbackCalled = true
+                            return data
+                        }
+                    }
+                },
+                path: 'data.xyz',
+            }
+        })
+
+        ds.connect().then(() => {
+            ds.set({
+                envelop: {
+                    message: "Hello World"
+                }
+            })
+
+            ds.write().then(() => {
+
+                ds.set({})
+                expect(ds.get()).to.be.deep.equal({});
+
+                setTimeout(() => {
+
+
+                    ds.read().then(() => {
+                        expect(ds.get()).to.be.deep.equal({envelop:{message: "Hello World"}});
+                        expect(writeCallbackCalled).to.be.true
+                        expect(readCallbackCalled).to.be.true
+                        done()
+                    }).catch((e) => {
+                        done(e)
+                    })
+                }, 200)
+
+            }).catch((err) => {
+                done(new Error(err));
+            })
+
+
+        }).catch((e) => {
+            done(e)
+        })
+
+
     })
-    
+
     it('should connect', function (done) {
         ds = new WebSocketDatasource({
             url: testUrl,
@@ -54,11 +138,11 @@ describe('Websocket', function () {
                 enabled: false
             }
         });
-        ds.connect()
-        setTimeout(() => {
-            expect(ds.isConnected()).to.be.true;
-            done();
-        }, 500);
+        ds.connect().then(() => {
+            done()
+        }).catch((e) => {
+            done(e)
+        })
 
 
     })
@@ -70,36 +154,37 @@ describe('Websocket', function () {
                 enabled: false
             }
         });
-        ds.connect()
-
-        ds.set({
-            data: {
-                message: "Hello World"
-            }
-        })
-
-        setTimeout(() => {
+        ds.connect().then(() => {
+            ds.set({
+                envelop: {
+                    message: "Hello World"
+                }
+            })
 
             ds.write().then(() => {
 
                 ds.set({})
                 expect(ds.get()).to.be.deep.equal({});
 
-
                 setTimeout(() => {
 
-                    expect(ds.get()).to.be.deep.equal({
-                        data: {
-                            message: "Hello World"
-                        }
-                    });
-                    done();
-                }, 1000);
+                    ds.read().then(() => {
+                    expect(ds.get()).to.be.deep.equal({envelop:{message: "Hello World"}});
+                    done()
+                }).catch((e) => {
+                    done(e)
+                })
+                },500)
+                
+
             }).catch((err) => {
                 done(new Error(err));
             })
-        }, 
-            500)
+
+
+        }).catch((e) => {
+            done(e)
+        })
 
 
     }).timeout(10000);

package/test/cases/monster.mjs

@@ -7,7 +7,7 @@ describe('Monster', function () {
         let monsterVersion
 
         /** don´t touch, replaced by make with package.json version */
-        monsterVersion = new Version('3.1.2')
+        monsterVersion = new Version('3.3.0')
 
         let m = getMonsterVersion();
 

package/test/cases/net/webconnect/message.mjs

@@ -0,0 +1,50 @@
+import {expect} from "chai"
+import {Message} from "../../../../../application/source/net/webconnect/message.mjs";
+
+describe('Message', function () {
+
+    it('construct withouth parameters should throw', function (done) {
+        
+        try {
+            new Message();
+            done(new Error('should throw'));
+        } catch (e) {
+            done();
+            return;
+        }
+
+    })
+    
+    it('from json should ' , function (done) {
+        const json = {
+            "id": "123",
+            "type": "test",
+            "data": {
+                "test": "test"
+            }
+        }
+        const message = Message.fromJSON(JSON.stringify(json));
+        const data = message.getData();
+        expect(data.id).to.equal(json.id);
+        expect(data.type).to.equal(json.type);
+        expect(data.data).to.deep.equal(json.data);
+        done();
+    })
+    
+    it ("to json should", function (done) {
+        const obj = {
+            "id": "123",
+            "type": "test",
+            "data": {
+                "test": "test"
+            }
+        }
+        const message = new Message(obj);
+        const data = JSON.stringify(message);
+        expect(data).to.equal('{"id":"123","type":"test","data":{"test":"test"}}');
+        done();
+    })
+
+
+
+});

package/test/cases/net/webconnect.mjs

@@ -0,0 +1,116 @@
+import {expect} from "chai"
+import {WebConnect} from "../../../../application/source/net/webconnect.mjs";
+import {Message} from "../../../../application/source/net/webconnect/message.mjs";
+import {Observer} from "../../../../application/source/types/observer.mjs";
+import {initWebSocket} from "../../util/websocket.mjs";
+
+const testUrl = "wss://ws.postman-echo.com/raw"
+
+describe('Websocket', function () {
+
+    let ds = undefined
+
+    before(function (done) {
+        initWebSocket().then(() => {
+            done()
+        }).catch((e) => {
+            done(e)
+        })
+    });
+
+    afterEach(function (done) {
+        if (ds) {
+            ds.close()
+        }
+
+        // without this, the node test will hang 
+        for (const sym of Object.getOwnPropertySymbols(ds)) {
+            if (sym.toString() === 'Symbol(connection)') {
+                if (ds[sym]?.socket?.['terminate']) {
+                    ds[sym]?.socket?.['terminate']()
+                }
+            }
+        }
+
+        done()
+    });
+
+
+    it('should transform data', function (done) {
+
+        ds = new WebConnect( {
+            url: testUrl,
+        })
+
+        ds.connect().then(() => {
+            
+            ds.attachObserver(new Observer(()=> {
+               done()
+            }))
+            
+            ds.send({
+                data: {
+                    message: "Hello World"
+                }
+            })
+
+        }).catch((e) => {
+            done(e)
+        })
+
+
+    })
+
+    it('should connect', function (done) {
+        ds = new WebConnect({
+            url: testUrl,
+            reconnect: {
+                enabled: false
+            }
+        });
+        ds.connect().then(() => {
+            done()
+        }).catch((e) => {
+            done(e)
+        })
+
+
+    })
+
+    it('should send message', function (done) {
+        ds = new WebConnect({
+            url: testUrl,
+            reconnect: {
+                enabled: false
+            }
+        });
+        ds.connect().then(() => {
+
+            ds.attachObserver(new Observer(()=> {
+                
+                expect(ds.dataReceived()).to.be.true
+                
+                try {
+                    const msg = ds.poll()
+                    expect(msg).to.be.instanceOf(Message)
+                    const data = msg.getData()
+                    expect(data).to.be.deep.equal({message: "Hello World"})
+                } catch (e) {
+                    done(e)
+                    return
+                }
+                done()
+            }))
+
+            ds.send({
+                    message: "Hello World"
+            })
+
+        }).catch((e) => {
+            done(e)
+        })
+
+
+    }).timeout(10000);
+
+});

package/test/cases/types/observablequeue.mjs

@@ -0,0 +1,17 @@
+import {expect} from "chai"
+import {ObservableQueue} from "../../../../application/source/types/observablequeue.mjs";
+import {Observer} from "../../../../application/source/types/observer.mjs";
+
+describe('ObservableQueue', function () {
+    describe('Observer', function () {
+
+        it('should notify', function (done) {
+            let queue = new ObservableQueue;
+            let o = new Observer((q) => {
+                done()
+            });
+            queue.attachObserver(o);
+            expect(queue.add('a')).to.be.instanceOf(ObservableQueue);
+        });
+    });
+})

package/test/cases/types/queue.mjs

@@ -30,7 +30,7 @@ describe('Queue', function () {
         });
 
     })
-    
+
     describe('add and clear', function () {
 
         it('should empty', function () {
@@ -42,4 +42,7 @@ describe('Queue', function () {
         });
 
     })
+
+
+    
 })