jsf.js_next_gen 4.1.0-beta.8 → 4.1.0-beta.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsf.js_next_gen",
-  "version": "4.1.0-beta.8",
+  "version": "4.1.0-beta.9",
   "description": "A next generation typescript reimplementation of jsf.js",
   "main": "dist/window/faces.js",
   "scripts": {

package/src/main/typescript/test/api/MyFacesABTest.spec.ts

@@ -0,0 +1,117 @@
+import {describe} from "mocha";
+import {StandardInits} from "../frameworkBase/_ext/shared/StandardInits";
+const defaultMyFaces = StandardInits.defaultMyFaces;
+import {expect} from "chai";
+
+describe('API tests', () => {
+
+    beforeEach(() => {
+        return defaultMyFaces();
+    });
+
+    it("must pass into ajax.request properly with user parameters", () => {
+        let passedSource = null;
+        let passedEvent = null;
+        let passedOptions = null;
+        let oldRequest = (window?.faces ?? window.jsf).ajax.request;
+        try {
+            (window?.faces ?? window.jsf).ajax.request = function(source, event, options) {
+                passedSource = source;
+                passedEvent = event;
+                passedOptions = options;
+            }
+            myfaces.ab(null, null, null, null, null, {}, {booga: "foobaz"});
+
+            expect(passedSource).to.eq(null);
+            expect(passedEvent).to.eq(null);
+            expect(passedOptions).to.deep.eq({params:{booga: "foobaz"}});
+        } finally {
+            (window?.faces ?? window.jsf).ajax.request = oldRequest;
+        }
+    })
+
+    it("must pass into ajax.request properly without user parameters", () => {
+        let passedSource = null;
+        let passedEvent = null;
+        let passedOptions = null;
+        let oldRequest = (window?.faces ?? window.jsf).ajax.request;
+        try {
+            (window?.faces ?? window.jsf).ajax.request = function(source, event, options) {
+                passedSource = source;
+                passedEvent = event;
+                passedOptions = options;
+            }
+            myfaces.ab(null, null, null, null, null, {});
+
+            expect(passedSource).to.eq(null);
+            expect(passedEvent).to.eq(null);
+            expect(passedOptions).to.deep.eq({params:{}});
+        } finally {
+            (window?.faces ?? window.jsf).ajax.request = oldRequest;
+        }
+    });
+
+    it("must pass into ajax.request properly with null options", () => {
+        let passedSource = null;
+        let passedEvent = null;
+        let passedOptions = null;
+        let oldRequest = (window?.faces ?? window.jsf).ajax.request;
+        try {
+            (window?.faces ?? window.jsf).ajax.request = function(source, event, options) {
+                passedSource = source;
+                passedEvent = event;
+                passedOptions = options;
+            }
+            myfaces.ab(null, null, null, null, null, null);
+
+            expect(passedSource).to.eq(null);
+            expect(passedEvent).to.eq(null);
+            expect(passedOptions).to.deep.eq({params:{}});
+        } finally {
+            (window?.faces ?? window.jsf).ajax.request = oldRequest;
+        }
+    });
+
+    it("must pass into ajax.request properly with null options and null user options", () => {
+        let passedSource = null;
+        let passedEvent = null;
+        let passedOptions = null;
+        let oldRequest = (window?.faces ?? window.jsf).ajax.request;
+        try {
+            (window?.faces ?? window.jsf).ajax.request = function(source, event, options) {
+                passedSource = source;
+                passedEvent = event;
+                passedOptions = options;
+            }
+            myfaces.ab(null, null, null, null, null, null, null);
+
+            expect(passedSource).to.eq(null);
+            expect(passedEvent).to.eq(null);
+            expect(passedOptions).to.deep.eq({params:{}});
+        } finally {
+            (window?.faces ?? window.jsf).ajax.request = oldRequest;
+        }
+    });
+
+    it("must pass into ajax.request properly without options and user params", () => {
+        let passedSource = null;
+        let passedEvent = null;
+        let passedOptions = null;
+        let oldRequest = (window?.faces ?? window.jsf).ajax.request;
+        try {
+            (window?.faces ?? window.jsf).ajax.request = function(source, event, options) {
+                passedSource = source;
+                passedEvent = event;
+                passedOptions = options;
+            }
+            myfaces.ab(null, null, null, null, null);
+
+            expect(passedSource).to.eq(null);
+            expect(passedEvent).to.eq(null);
+            expect(passedOptions).to.deep.eq({params:{}});
+        } finally {
+            (window?.faces ?? window.jsf).ajax.request = oldRequest;
+        }
+    });
+
+});

package/src/main/typescript/test/frameworkBase/LangTest.spec.ts

@@ -0,0 +1,145 @@
+import {expect} from 'chai';
+import {describe, it} from 'mocha';
+import {Lang} from "mona-dish";
+
+const equalsIgnoreCase = Lang.equalsIgnoreCase;
+const assertType = Lang.assertType;
+const objToArray = Lang.objToArray;
+const isFunc = Lang.isFunc;
+const isString = Lang.isString;
+const trim = Lang.trim;
+const strToArray = Lang.strToArray;
+import {ExtLang} from "../../impl/util/Lang";
+const keyValToStr = ExtLang.keyValToStr;
+
+
+const jsdom = require("jsdom");
+const {JSDOM} = jsdom;
+const dom = new JSDOM(`
+    <!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Title</title>
+    </head>
+    <body>
+        <div />
+        <div />
+        <div />
+        <div />
+    </body>
+    </html>
+    
+    `)
+
+export const window = dom.window;
+
+
+function hello_world() {
+    return "Hello World!"
+}
+
+describe('Hello World!', () => {
+    before(() => {
+        (global as any).window = window;
+        (global as any).document = window.document;
+
+    });
+    it('first test', () => {
+        const result = hello_world();
+        expect(result).to.equal('Hello World!');
+    });
+});
+
+class Probe {
+
+    val1 = 1;
+    val2 = 2;
+    val3 = 3;
+
+    constructor() {
+    }
+}
+
+describe('Lang tests', () => {
+    it('initializable', () => {
+        const lang = Lang;
+        expect(lang).to.exist;
+    });
+
+    it('strToArray working', () => {
+        let arr = strToArray("hello.world.from.me", /\./gi);
+
+        expect(arr).to.exist;
+        expect(arr.length).to.eq(4);
+        expect(arr[3]).to.eq("me");
+
+    });
+
+    it('trim working', () => {
+        let origStr = " hello world from me    ";
+        let trimmed = trim(origStr);
+        expect(trimmed).to.exist;
+        expect(trimmed).to.eq("hello world from me");
+
+    });
+
+    it('isString working', () => {
+        expect(isString(" ")).to.be.true;
+        expect(isString('')).to.be.true;
+        expect(isString(null)).to.be.false;
+        expect(isString(undefined)).to.be.false;
+        expect(isString(function () {
+            return true;
+        })).to.be.false;
+        expect(isString(new Probe())).to.be.false;
+    });
+
+    it('isFunc working', () => {
+        expect(isFunc(() => {
+        })).to.be.true;
+        expect(isFunc(function () {
+            return true;
+        })).to.be.true;
+        expect(isFunc("blarg")).to.be.false;
+        expect(isFunc(new Probe())).to.be.false;
+    });
+
+    it('objToArray working', () => {
+        let obj_probe = new Probe();
+        let resultArr = objToArray(obj_probe);
+        expect(assertType(resultArr, Array)).to.be.true;
+        expect(resultArr.length).to.eq(0);
+        obj_probe = window.document.body.querySelectorAll("div");
+        resultArr = objToArray(obj_probe);
+        expect(resultArr.length).to.eq(4);
+        expect(assertType(resultArr, Array)).to.be.true;
+    });
+
+    it('keyval to string working', () => {
+        let keyval = keyValToStr("key", "val", ":")
+        expect(keyval).to.eq("key:val");
+
+    });
+
+    it('equals ignore case test', () => {
+        expect(equalsIgnoreCase(null, null as any)).to.be.true;
+        expect(equalsIgnoreCase("", "")).to.be.true;
+        expect(equalsIgnoreCase("null", "NuLL")).to.be.true;
+        expect(equalsIgnoreCase("null ", "NuLL")).to.be.false;
+        expect(equalsIgnoreCase("null", "NuLL2")).to.be.false;
+
+    });
+
+    /*it('form data test', () => {
+        const lang = Lang;
+        let sourceData: any = [1, 2, 3];
+        let formData: FormDataDecorator = createFormDataDecorator(sourceData);
+        expect(formData instanceof FormDataDecorator).to.be.true;
+        expect(formData.makeFinal()).to.eq("1&2&3");
+
+        formData.append("bla", "arg");
+        expect(formData.makeFinal()).to.eq("1&2&3&bla=arg");
+    });*/
+});
+