@schukai/monster 1.24.0 → 1.25.0

package/test/cases/dom/resource/link/stylesheet.js

@@ -0,0 +1,101 @@
+'use strict';
+
+import chai from "chai"
+import {Stylesheet} from "../../../../../source/dom/resource/link/stylesheet.js";
+import {DataUrl} from "../../../../../source/types/dataurl.js";
+import {ID} from "../../../../../source/types/id.js";
+import {chaiDom} from "../../../../util/chai-dom.js";
+import {cleanupDOMFromTesting, initMutationObserverForTesting} from "../../../../util/cleanupdom.js";
+import {initJSDOM} from "../../../../util/jsdom.js";
+
+let expect = chai.expect;
+
+chai.use(chaiDom);
+
+let html1 = `
+
+`;
+
+
+describe('Stylesheet', function () {
+
+    before(function (done) {
+        initJSDOM({
+            runScripts: "dangerously",
+            resources: "usable"
+        }).then(() => {
+            done()
+        });
+    });
+
+    beforeEach(() => {
+        initMutationObserverForTesting()
+    })
+
+    afterEach(() => {
+        cleanupDOMFromTesting();
+    })
+
+    describe('Stylesheet()', function () {
+        it('connect().available()', function (done) {
+
+            const stylesheet = new Stylesheet({
+                href: new DataUrl('', 'text/css').toString(),
+            });
+
+            stylesheet.connect().available().then(() => {
+                const id = stylesheet.getOption('id')
+                done()
+            }).catch(e => done(e));
+
+        })
+    });
+
+    describe('External Stylesheet', () => {
+
+        let id = new ID('Stylesheet').toString();
+        let stylesheet, url = 'https://monsterjs.org/assets/empty.css?' + id;
+
+        beforeEach(() => {
+
+            stylesheet = new Stylesheet({
+                href: url,
+                id: id,
+            });
+
+        });
+
+        it('append and remove Stylesheet ', (done) => {
+
+            expect(stylesheet.isConnected()).to.be.false;
+
+            stylesheet.connect().available().then(() => {
+                expect(stylesheet.isConnected()).to.be.true;
+                expect(document.querySelector('[href="' + url + '"]')).to.exist;
+
+                document.getElementById(id).remove();
+                expect(stylesheet.isConnected()).to.be.false;
+                expect(document.querySelector('[href="' + url + '"]')).not.to.exist;
+
+                stylesheet.connect().available().then(() => {
+                    expect(stylesheet.isConnected()).to.be.true;
+                    expect(document.querySelector('[href="' + url + '"]')).to.exist;
+
+                    document.getElementById(id).remove();
+                    expect(document.querySelector('[href="' + url + '"]')).not.to.exist;
+                    expect(stylesheet.isConnected()).to.be.false;
+
+                    done()
+                }).catch(e => done(e));
+
+
+            }).catch(e => done(e));
+
+
+        });
+
+
+    });
+
+
+});

package/test/cases/dom/resource/link.js

@@ -0,0 +1,101 @@
+'use strict';
+
+import chai from "chai"
+import {Link} from "../../../../source/dom/resource/link.js";
+import {DataUrl} from "../../../../source/types/dataurl.js";
+import {ID} from "../../../../source/types/id.js";
+import {chaiDom} from "../../../util/chai-dom.js";
+import {cleanupDOMFromTesting, initMutationObserverForTesting} from "../../../util/cleanupdom.js";
+import {initJSDOM} from "../../../util/jsdom.js";
+
+let expect = chai.expect;
+
+chai.use(chaiDom);
+
+let html1 = `
+
+`;
+
+
+describe('Link', function () {
+
+    let mutationobserver, addedNodes=[];
+
+    before(function (done) {
+        initJSDOM().then(() => {
+            done()
+        });
+    });
+
+    beforeEach(() => {
+        initMutationObserverForTesting()
+    })
+
+    afterEach(() => {
+        cleanupDOMFromTesting();
+    })
+
+    describe('Link()', function () {
+        it('connect().available()', function (done) {
+
+            const link = new Link({
+                href: new DataUrl('', 'text/css').toString(),
+                rel: 'stylesheet'
+            });
+
+            link.connect().available().then(() => {
+                done()
+            }).catch(e => done(e));
+
+        })
+    });
+
+    describe('External Link', () => {
+
+        let id = new ID('link').toString();
+        let link, url = 'https://monsterjs.org/assets/empty.css?' + id;
+
+        beforeEach(() => {
+
+            link = new Link({
+                href: url,
+                id: id,
+                rel: 'stylesheet'
+            });
+
+        });
+
+        it('append and remove Link ', (done) => {
+
+            expect(link.isConnected()).to.be.false;
+
+            link.connect().available().then(() => {
+                expect(link.isConnected()).to.be.true;
+                expect(document.querySelector('[href="' + url + '"]')).to.exist;
+
+                document.getElementById(id).remove();
+                expect(link.isConnected()).to.be.false;
+                expect(document.querySelector('[href="' + url + '"]')).not.to.exist;
+
+                link.connect().available().then(() => {
+                    expect(link.isConnected()).to.be.true;
+                    expect(document.querySelector('[href="' + url + '"]')).to.exist;
+
+                    document.getElementById(id).remove();
+                    expect(document.querySelector('[href="' + url + '"]')).not.to.exist;
+                    expect(link.isConnected()).to.be.false;
+
+                    done()
+                }).catch(e => done(e));
+
+
+            }).catch(e => done(e));
+
+
+        });
+
+
+    });
+
+
+});

package/test/cases/dom/resource/script.js

@@ -0,0 +1,115 @@
+'use strict';
+
+import chai from "chai"
+import {Script} from "../../../../source/dom/resource/script.js";
+import {DataUrl} from "../../../../source/types/dataurl.js";
+import {ID} from "../../../../source/types/id.js";
+import {chaiDom} from "../../../util/chai-dom.js";
+import {cleanupDOMFromTesting, initMutationObserverForTesting} from "../../../util/cleanupdom.js";
+import {initJSDOM} from "../../../util/jsdom.js";
+
+let expect = chai.expect;
+
+chai.use(chaiDom);
+
+let html1 = `
+
+`;
+
+
+describe('Script', function () {
+
+    before(function (done) {
+        initJSDOM().then(() => {
+            done()
+        });
+    });
+
+    beforeEach(() => {
+        initMutationObserverForTesting()
+    })
+
+    afterEach(() => {
+        cleanupDOMFromTesting();
+    })
+
+    describe('Script()', function () {
+        it('setEventTypes()', function (done) {
+
+            const script = new Script({
+                src: new DataUrl('', 'text/javascript').toString(),
+                async: true,
+                crossOrigin: 'anonymous',
+                defer: false,
+                integrity: undefined,
+                nomodule: false,
+                nonce: undefined,
+                referrerpolicy: undefined,
+                type: 'text/javascript'
+            });
+
+            script.connect().available().then(() => {
+
+                const id = script.getOption('id')
+                done()
+            }).catch(e => done(e));
+
+        })
+    });
+
+    describe('External JS', () => {
+
+        let id = new ID('script').toString();
+        let server, script, url = 'https://monsterjs.org/assets/empty.js?' + id;
+
+        beforeEach(() => {
+
+            script = new Script({
+                src: url,
+                async: true,
+                crossOrigin: 'anonymous',
+                defer: false,
+                integrity: undefined,
+                nomodule: false,
+                nonce: undefined,
+                referrerpolicy: undefined,
+                type: 'text/javascript',
+                id: id
+            });
+
+        });
+
+        it('append and remove script ', (done) => {
+
+            expect(script.isConnected()).to.be.false;
+
+            script.connect().available().then(() => {
+                expect(script.isConnected()).to.be.true;
+                expect(document.querySelector('[src="' + url + '"]')).to.exist;
+
+                document.getElementById(id).remove();
+                expect(script.isConnected()).to.be.false;
+                expect(document.querySelector('[src="' + url + '"]')).not.to.exist;
+
+                script.connect().available().then(() => {
+                    expect(script.isConnected()).to.be.true;
+                    expect(document.querySelector('[src="' + url + '"]')).to.exist;
+
+                    document.getElementById(id).remove();
+                    expect(document.querySelector('[src="' + url + '"]')).not.to.exist;
+                    expect(script.isConnected()).to.be.false;
+
+                    done()
+                }).catch(e => done(e));
+
+
+            }).catch(e => done(e));
+
+
+        });
+
+
+    });
+
+
+});

package/test/cases/dom/resourcemanager.js

@@ -0,0 +1,118 @@
+'use strict';
+
+import {expect} from "chai"
+
+import {ResourceManager} from "../../../source/dom/resourcemanager.js";
+import {cleanupDOMFromTesting, initMutationObserverForTesting} from "../../util/cleanupdom.js";
+import {initJSDOM} from "../../util/jsdom.js";
+
+describe('ResourceManager', function () {
+
+    let fetchReference, returnStatus;
+
+    before(function (done) {
+        initJSDOM().then(() => {
+            done()
+        }).catch(e => done(e));
+    });
+
+    afterEach(() => {
+        global['fetch'] = fetchReference;
+        cleanupDOMFromTesting();
+    })
+
+    beforeEach(() => {
+
+        initMutationObserverForTesting()
+
+        returnStatus = 200;
+        fetchReference = global['fetch'];
+        global['fetch'] = function (url, options) {
+
+            if (!url) throw new Error('missing url')
+
+            return new Promise((resolve, reject) => {
+                resolve({
+                    text: function () {
+                        return JSON.stringify({
+                            a: "test"
+                        })
+                    },
+                    status: returnStatus
+                });
+            })
+
+        };
+
+    })
+
+    describe('new', function () {
+        it('new ResourceManager() should return ResourceManager object', function () {
+            let d = new ResourceManager();
+            expect(d).to.be.instanceOf(ResourceManager);
+        });
+    });
+
+    describe('load resources', function () {
+
+        let manager;
+
+        beforeEach(() => {
+            manager = new ResourceManager();
+        })
+
+        it('add script should instance of ResourceManager', function () {
+            expect(manager.addScript('/example.js')).to.be.instanceOf(ResourceManager);
+        });
+
+        it('add style should instance of ResourceManager', function () {
+            expect(manager.addStylesheet('/style.js')).to.be.instanceOf(ResourceManager);
+        });
+
+        it('add data should instance of ResourceManager', function () {
+            expect(manager.addData('/data.json')).to.be.instanceOf(ResourceManager);
+        });
+
+        describe('connect resources', function () {
+            it('add script and connect should instance of ResourceManager', function () {
+                expect(manager.addScript('/example.js').connect()).to.be.instanceOf(ResourceManager);
+            });
+
+            it('add style and connect should instance of ResourceManager', function () {
+                expect(manager.addStylesheet('/style.js').connect()).to.be.instanceOf(ResourceManager);
+            });
+
+            it('add data and connect  should instance of ResourceManager', function () {
+                expect(manager.addData('/data.json').connect()).to.be.instanceOf(ResourceManager);
+            });
+        })
+
+
+        describe('check availability resources', function () {
+            it('add script and check availability should return Promise', function () {
+                expect(manager.addScript('/example.js').available()).to.be.instanceOf(Promise);
+            });
+
+            it('add style and check availability should should return Promise', function () {
+                expect(manager.addStylesheet('/style.js').available()).to.be.instanceOf(Promise);
+            });
+
+            it('add data and check availability  should should return Promise', function () {
+                expect(manager.addData('/data.json').available()).to.be.instanceOf(Promise);
+            });
+        })
+
+        describe('check availability example.json', function () {
+            it('add data and check content', function (done) {
+                manager.addData('https://example.com/example.json').connect().available().then(r => {
+                    expect(document.querySelector('html').outerHTML).contains('>{"a":"test"}</script></head>');
+                    done();
+                }).catch(e => done(e));
+            });
+
+        })
+
+    });
+
+
+});

package/test/cases/dom/worker/factory.js

@@ -0,0 +1,63 @@
+import {expect} from "chai"
+
+import {Factory} from "../../../../source/dom/worker/factory.js";
+import {getGlobal} from "../../../../source/types/global.js";
+import {initJSDOM, isNode} from "../../../util/jsdom.js";
+
+const global = getGlobal();
+
+describe('Worker', function () {
+
+    before(function (done) {
+
+        if (isNode()) {
+            Object.defineProperty(global['URL'], 'createObjectURL', {
+                writable: true,
+                value: () => {
+                    return "/example.js"
+                }
+            })
+
+            global['Worker'] = class {
+                terminate() {
+                    
+                }
+
+                onerror() {
+                    
+                }
+
+                onmessage() {
+                    
+                }
+            }
+
+            let a = typeof global['Worker'];
+            let a1 = typeof Worker;
+
+        }
+
+        const jsdom = initJSDOM().then(() => {
+            done();
+        });
+
+
+    })
+
+    describe('Factory', function () {
+
+        it('create worker', function () {
+
+            const factory = new Factory();
+            const worker = factory.createFromScript('console.log("hello world");')
+            expect(worker).is.instanceof(Worker);
+
+            expect(factory.terminate(worker)).is.instanceof(Factory)
+
+
+        });
+
+    });
+
+
+});

package/test/cases/monster.js

@@ -9,7 +9,7 @@ describe('Monster', function () {
         let monsterVersion
 
     /**#@+ dont touch, replaced by make with package.json version */
-    monsterVersion = new Version('1.24.0')
+    monsterVersion = new Version('1.25.0')
     /**#@-*/
 
         let m = Monster.getVersion();

package/test/cases/types/uuid.js

@@ -0,0 +1,42 @@
+import * as Crypto from "@peculiar/webcrypto";
+import {expect} from "chai"
+import {UUID} from "../../../source/types/uuid.js";
+
+if (!global['crypto']) {
+    global['crypto'] = new Crypto.Crypto();
+}
+
+
+describe('UUID', function () {
+
+    describe('.toString()', function () {
+        let uuid = new UUID()
+        let result = uuid.toString();
+
+        it('should return a string', function () {
+            expect(result).is.a('string')
+            expect(result.length).is.equal(36)
+        });
+
+        it('test format', function (done) {
+
+            const regexExp = /^[A-F\d]{8}-[A-F\d]{4}-4[A-F\d]{3}-[89AB][A-F\d]{3}-[A-F\d]{12}$/i;
+
+            for (let i = 0; i < 2000; i++) {
+                const u = new UUID().toString();
+                const r = regexExp.test(u);
+
+                if (r !== true) {
+                    done('no uuid ' + u + ' => ' + r);
+                    return;
+                }
+            }
+
+            done();
+
+        });
+
+    });
+
+});
+

package/test/cases/util/freeze.js

@@ -10,13 +10,39 @@ describe('deepFreeze', function () {
 
             let obj1 = {
                 a: {
-                    b: {}
+                    b: {
+                        c:1
+                    }
                 }
             };
             
-            expect(() => obj1.a.b.c = 1).to.not.throw(TypeError);
-            const  obj2 = deepFreeze(obj1);
-            expect(() => obj2.a.b.c = 1).to.throw(TypeError);
+            let obj2 = {
+                a: {
+                    b: {
+                        c:2
+                    }
+                }
+            };
+
+            expect(obj2).to.not.eql(obj1)
+            obj1.a.b.c = 2;
+            expect(obj2).to.eql(obj1);
+
+            const obj1Freezed = deepFreeze(obj1);
+
+            expect(obj2).to.eql(obj1Freezed);
+
+            try {
+                // https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Object/freeze
+                // no change to the object, exception depends on mode (strict ES 2015, etc)
+                obj1Freezed.a.b.c = 3    
+            } catch (_) {
+
+            }
+
+            expect(obj2).to.eql(obj1Freezed);
+            
+            
         });
 
     });

package/test/util/cleanupdom.js

@@ -0,0 +1,48 @@
+'use strict';
+
+
+let addedNodes, mutationobserver;
+
+function init() {
+
+    addedNodes = [];
+    mutationobserver = new MutationObserver(function (mutations) {
+        mutations.forEach(function (mutation) {
+            if (mutation.type === 'childList' && mutation.removedNodes) {
+
+                mutation.addedNodes.forEach((n) => {
+                    if (n instanceof HTMLElement) {
+                        addedNodes.push(n);
+                    }
+                })
+            }
+
+        });
+    });
+
+
+}
+
+
+/**
+ *
+ */
+export function initMutationObserverForTesting() {
+
+    if (mutationobserver === undefined) {
+        init()
+    }
+
+    mutationobserver.observe(document.querySelector('head'), {childList: true});
+}
+
+/**
+ *
+ */
+export function cleanupDOMFromTesting() {
+    mutationobserver.disconnect();
+
+    for (const n of addedNodes) {
+        n.remove();
+    }
+}