jsf.js_next_gen 4.0.0-RC.3 → 4.0.0-RC.31

package/src/main/typescript/test/xhrCore/RequestParamsTest.spec.ts

@@ -18,9 +18,47 @@ import {Implementation} from "../../impl/AjaxImpl";
 import {StandardInits} from "../frameworkBase/_ext/shared/StandardInits";
 
 import protocolPage = StandardInits.protocolPage;
-import {DQ} from "mona-dish";
-import {XhrFormData} from "../../impl/xhrCore/XhrFormData";
-import { expect } from "chai";
+import {Config, DQ, Stream} from "mona-dish";
+import {expect} from "chai";
+import HTML_PREFIX_EMBEDDED_BODY = StandardInits.HTML_PREFIX_EMBEDDED_BODY;
+import {it} from "mocha";
+import {decodeEncodedValues} from "../../impl/util/FileUtils";
+import {ExtConfig} from "../../impl/util/ExtDomQuery";
+
+/**
+ * merges a list of key value entries into a target config
+ * @param target the target receiving the key value entries
+ * @param keyValueEntries a list of key value entries divided by =
+ * @param paramsMapper a key value remapper
+ */
+function mergeKeyValueEntries(target: Config, keyValueEntries: Stream<string[]>, paramsMapper = (key, value) => [key, value]) {
+
+    function fixKeyWithoutVal(keyVal: string[]) {
+        return keyVal.length < 3 ? [keyVal?.[0] ?? [], keyVal?.[1] ?? []] : keyVal;
+    }
+
+    let toMerge = new ExtConfig({});
+    keyValueEntries
+        //special case of having keys without values
+        .map(keyVal => fixKeyWithoutVal(keyVal))
+        .map(keyVal => paramsMapper(keyVal[0] as string, keyVal[1]))
+        .each(keyVal => {
+            let value = keyVal?.splice(1)?.join("") ?? "";
+            if(toMerge.getIfPresent(keyVal[0]).isPresent()) {
+                toMerge.append(keyVal[0] as string).value = value;
+            } else {
+                toMerge.assign(keyVal[0] as string).value = value;
+            }
+        });
+
+    target.shallowMerge(toMerge);
+}
+
+function getFormData(requestBody: string): Config {
+    let ret = new Config({});
+    mergeKeyValueEntries(ret, decodeEncodedValues(requestBody));
+    return ret;
+}
 
 describe("test for proper request param patterns identical to the old implementation", function () {
     const UPDATE_INSERT_2 = {
@@ -35,12 +73,12 @@ describe("test for proper request param patterns identical to the old implementa
     /**
      * matches two maps for absolute identicality
      */
-    let matches = (item1: {[key: string]: any}, item2: {[key: string]: any}): boolean => {
-        if(Object.keys(item1).length != Object.keys(item2).length) {
+    let matches = (item1: { [key: string]: any }, item2: { [key: string]: any }): boolean => {
+        if (Object.keys(item1).length != Object.keys(item2).length) {
             return false;
         }
-        for(let key in item1) {
-            if((!(key in item2)) || item1[key] != item2[key]) {
+        for (let key in item1) {
+            if ((!(key in item2)) || item1[key] != item2[key]) {
                 return false;
             }
         }
@@ -77,50 +115,153 @@ describe("test for proper request param patterns identical to the old implementa
         this.closeIt();
     });
 
-    it("must pass updateinsert2 with proper parameters", function() {
+    it("must pass updateinsert2 with proper parameters", function () {
         DQ.byId("cmd_update_insert2").click();
 
         let requestBody = this.requests[0].requestBody;
-        let formData = new XhrFormData(requestBody);
+        let formData = getFormData(requestBody);
 
         expect(matches(formData.value, UPDATE_INSERT_2)).to.be.true;
-
     });
 
 
-    it("must handle base64 encoded strings properly as request data", function() {
+    it("must handle base64 encoded strings properly as request data", function () {
         let probe = "YWFhYWFhc1Rlc3RpdCDDpGtvNDU5NjczMDA9PSsrNDU5MGV3b3UkJiUmLyQmJQ==";
         DQ.byId("jakarta.faces.ViewState").inputValue.value = probe;
         DQ.byId("cmd_update_insert2").click();
         let requestBody = this.requests[0].requestBody;
         //We check if the base64 encoded string matches the original
-        let formData = new XhrFormData(requestBody);
+        let formData = getFormData(requestBody);
 
-        expect(decodeURIComponent(formData.getIf("jakarta.faces.ViewState").value) == probe).to.be.true;
+        expect(formData.getIf("jakarta.faces.ViewState").value == probe).to.be.true;
     });
 
 
-    it("must handle empty parameters properly", function() {
+    it("must handle empty parameters properly", function () {
         let probe = "";
         DQ.byId("jakarta.faces.ViewState").inputValue.value = probe;
         DQ.byId("cmd_update_insert2").click();
         let requestBody = this.requests[0].requestBody;
         //We check if the base64 encoded string matches the original
-        let formData = new XhrFormData(requestBody);
+        let formData = getFormData(requestBody);
 
         expect(decodeURIComponent(formData.getIf("jakarta.faces.ViewState").value) == probe).to.be.true;
     });
 
     //KssbpZfCe+0lwDhgMRQ44wRFkaM1o1lbMMUO3lini5YhXWm6
 
-    it("must handle base64 special cases properly (+ in encoding)", function() {
+    it("must handle base64 special cases properly (+ in encoding)", function () {
         let probe = "KssbpZfCe+0lwDhgMRQ44wRFkaM1o1lbMMUO3lini5YhXWm6";
         DQ.byId("jakarta.faces.ViewState").inputValue.value = probe;
         DQ.byId("cmd_update_insert2").click();
         let requestBody = this.requests[0].requestBody;
         //We check if the base64 encoded string matches the original
-        let formData = new XhrFormData(requestBody);
+        let formData = getFormData(requestBody);
 
         expect(decodeURIComponent(formData.getIf("jakarta.faces.ViewState").value) == probe).to.be.true;
     });
+
+    it("must handle prefixed inputs properly (prefixes must be present) faces4", function (done) {
+        window.document.body.innerHTML = HTML_PREFIX_EMBEDDED_BODY;
+
+        global["debug_inp"] = true;
+        //we now run the tests here
+        try {
+
+            let event = {
+                isTrusted: true,
+                type: 'change',
+                target: document.getElementById("page:input::field"),
+                currentTarget: document.getElementById("page:input::field")
+            };
+            faces.ajax.request(document.getElementById("page:input"), event as any, {
+                render: "page:output",
+                execute: "page:input",
+                params: {
+                    "booga2.xxx": "yyy",
+                    "javax.faces.behavior.event": "change",
+                    "booga": "bla"
+                },
+            });
+        } catch (err) {
+            console.error(err);
+            expect(false).to.eq(true);
+        }
+        const requestBody = this.requests[0].requestBody;
+        //We check if the base64 encoded string matches the original
+        expect(requestBody.indexOf("javax.faces.behavior.event")).to.not.eq(-1);
+        expect(requestBody.indexOf("javax.faces.behavior.event=change")).to.not.eq(-1);
+        expect(requestBody.indexOf("page%3Ainput=input_value")).to.not.eq(-1);
+        done();
+    });
+
+
+
+
+    /**
+     * This test is based on Tobago 6 (Jakarte EE 9).
+     */
+    it("must handle ':' in IDs properly", function (done) {
+        window.document.body.innerHTML = `
+
+<tobago-page locale="en" class="container-fluid" id="page" focus-on-error="true" wait-overlay-delay-full="1000" wait-overlay-delay-ajax="1000">
+    <form action="/content/010-input/10-in/In.xhtml?jfwid=q6qbeuqed" id="page::form" method="post" accept-charset="UTF-8" data-tobago-context-path="">
+        <input type="hidden" name="jakarta.faces.source" id="jakarta.faces.source" disabled="disabled">
+        <tobago-focus id="page::lastFocusId">
+            <input type="hidden" name="page::lastFocusId" id="page::lastFocusId::field">
+        </tobago-focus>
+        <input type="hidden" name="org.apache.myfaces.tobago.webapp.Secret" id="org.apache.myfaces.tobago.webapp.Secret" value="secretValue">
+        <tobago-in id="page:input" class="tobago-auto-spacing">
+            <input type="text" name="page:input" id="page:input::field" class="form-control" value="Bob">
+            <tobago-behavior event="change" client-id="page:input" field-id="page:input::field" execute="page:input" render="page:output"></tobago-behavior>
+        </tobago-in>
+        <tobago-out id="page:output" class="tobago-auto-spacing">
+            <span class="form-control-plaintext"></span>
+        </tobago-out>
+        <div class="tobago-page-menuStore">
+        </div>
+        <span id="page::faces-state-container">
+            <input type="hidden" name="jakarta.faces.ViewState" id="j_id__v_0:jakarta.faces.ViewState:1" value="viewStateValue" autocomplete="off">
+            <input type="hidden" name="jakarta.faces.RenderKitId" value="tobago">
+            <input type="hidden" id="j_id__v_0:jakarta.faces.ClientWindow:1" name="jakarta.faces.ClientWindow" value="clientWindowValue">
+        </span>
+    </form>
+</tobago-page>
+`;
+
+        //we now run the tests here
+        try {
+
+            let event = {
+                isTrusted: true,
+                type: 'change',
+                target: document.getElementById("page:input::field"),
+                currentTarget: document.getElementById("page:input::field")
+            };
+            global.debug2 = true;
+            faces.ajax.request(document.getElementById("page:input"), event as any, {
+                "jakarta.faces.behavior.event": 'change',
+                execute: "page:input",
+                render: "page:output"
+            });
+        } catch (err) {
+            console.error(err);
+            expect(false).to.eq(true);
+        }
+        const requestBody = this.requests[0].requestBody;
+        expect(requestBody.indexOf("org.apache.myfaces.tobago.webapp.Secret=secretValue")).to.not.eq(-1);
+        expect(requestBody.indexOf("page%3Ainput=Bob")).to.not.eq(-1);
+        expect(requestBody.indexOf("jakarta.faces.ViewState=viewStateValue")).to.not.eq(-1);
+        expect(requestBody.indexOf("jakarta.faces.RenderKitId=tobago")).to.not.eq(-1);
+        expect(requestBody.indexOf("jakarta.faces.ClientWindow=clientWindowValue")).to.not.eq(-1);
+        expect(requestBody.indexOf("jakarta.faces.behavior.event=change")).to.not.eq(-1);
+        expect(requestBody.indexOf("jakarta.faces.partial.event=change")).to.not.eq(-1);
+        expect(requestBody.indexOf("jakarta.faces.source=page%3Ainput")).to.not.eq(-1);
+        expect(requestBody.indexOf("jakarta.faces.partial.ajax=true")).to.not.eq(-1);
+        expect(requestBody.indexOf("page%3A%3Aform=page%3A%3Aform")).to.not.eq(-1);
+        expect(requestBody.indexOf("jakarta.faces.partial.execute=page%3Ainput")).to.not.eq(-1);
+        expect(requestBody.indexOf("jakarta.faces.partial.render=page%3Aoutput")).to.not.eq(-1);
+        done();
+    });
+
 });

package/src/main/typescript/test/xhrCore/RequestTest.spec.ts

@@ -20,7 +20,7 @@ import {expect} from "chai";
 import {StandardInits} from "../frameworkBase/_ext/shared/StandardInits";
 import {DomQuery} from "mona-dish";
 import {
-    COMPLETE,
+    COMPLETE, EMPTY_STR,
     P_AJAX,
     P_EXECUTE,
     P_PARTIAL_SOURCE,
@@ -464,9 +464,9 @@ describe('Tests after core when it hits response', function () {
                 },
                 onerror: (error: any) => {
                     expect(error.type).to.eq("error");
-                    expect(!!error.status).to.eq(true);
+                    expect(error.status).to.eq(EMPTY_STR);
                     expect(!!error.message).to.eq(true);
-                    expect(!!error.source).to.eq(true);
+                    expect(!!error.source?.id).to.eq(true);
                     expect(!!error.responseCode).to.eq(true);
                     expect(!!error.responseText).to.eq(true);
                     expect(!error.responseXML).to.eq(true);
@@ -491,5 +491,72 @@ describe('Tests after core when it hits response', function () {
         }
 
     });
+
+    // We can cover this TCK issue in a simple code unit test, the case is simple enough
+    it("must throw an error on invalid delays (MYFACES-4499, TCK_ISSUE320IT )", (done) => {
+
+        let element = DomQuery.byId("input_2").getAsElem(0).value;
+        try {
+            faces.ajax.request(element, null, {
+                execute: "input_1",
+                render: "@form",
+                delay: NaN,
+                params: {
+                    pass1: "pass1",
+                    pass2: "pass2",
+                }
+            });
+        } catch (e) {
+            expect(e.message.indexOf("NaN") > 0).to.eq(true, "Invalid NaN in message");
+            done();
+            return;
+        }
+        done("Expecting a client error to be thrown")
+    });
+
+    it("must throw an error on invalid delays (MYFACES-4499, TCK_ISSUE320IT ) - 2", (done) => {
+
+        let element = DomQuery.byId("input_2").getAsElem(0).value;
+        try {
+            faces.ajax.request(element, null, {
+                execute: "input_1",
+                render: "@form",
+                delay: -1,
+                params: {
+                    pass1: "pass1",
+                    pass2: "pass2",
+                }
+            });
+        } catch (e) {
+            expect(e.message.indexOf("-1") > 0).to
+                .eq(true, "Invalid integer value in message");
+            done();
+            return;
+        }
+        done("Expecting a client error to be thrown")
+    });
+    it("must throw an error on invalid delays (MYFACES-4499, TCK_ISSUE320IT ) - 3", (done) => {
+
+        let element = DomQuery.byId("input_2").getAsElem(0).value;
+        try {
+            faces.ajax.request(element, null, {
+                execute: "input_1",
+                render: "@form",
+                delay: "booga",
+                params: {
+                    pass1: "pass1",
+                    pass2: "pass2",
+                }
+            });
+        } catch (e) {
+            expect(e.message.indexOf("booga") > 0).to.be
+                .eq(true, "Invalid string value in message");
+            done();
+            return;
+        }
+        done("Expecting a client error to be thrown")
+    });
+
+
 });
 

package/src/main/typescript/test/xhrCore/RequestTest_23.spec.ts

@@ -24,7 +24,7 @@ import {expect} from "chai";
 import {StandardInits} from "../frameworkBase/_ext/shared/StandardInits";
 import {DomQuery} from "mona-dish";
 import {
-    COMPLETE,
+    COMPLETE, EMPTY_STR,
     SUCCESS
 } from "../../impl/core/Const";
 ;
@@ -65,6 +65,7 @@ let {
 
 import STD_XML = StandardInits.STD_XML;
 import defaultMyFaces23 = StandardInits.defaultMyFaces23;
+import HTML_PREFIX_EMBEDDED_BODY = StandardInits.HTML_PREFIX_EMBEDDED_BODY;
 
 declare var jsf: any;
 declare var Implementation: any;
@@ -333,9 +334,9 @@ describe('Tests after core when it hits response', function () {
                 pass2: "pass2",
                 onerror: (error: any) => {
                     expect(error.type).to.eq("error");
-                    expect(!!error.status).to.eq(true);
+                    expect(error.status).to.eq(EMPTY_STR);
                     expect(!!error.message).to.eq(true);
-                    expect(!!error.source).to.eq(true);
+                    expect(!!error.source.id).to.eq(true);
                     expect(!!error.responseCode).to.eq(true);
                     expect(!!error.responseText).to.eq(true);
                     expect(!error.responseXML).to.eq(true);
@@ -360,5 +361,40 @@ describe('Tests after core when it hits response', function () {
         }
 
     });
+
+    it("must handle prefixed inputs properly (prefixes must be present)", function (done) {
+        window.document.body.innerHTML = HTML_PREFIX_EMBEDDED_BODY;
+
+        //we now run the tests here
+        try {
+
+            let event = {
+                isTrusted: true,
+                type: 'change',
+                target: document.getElementById("page:input::field"),
+                currentTarget: document.getElementById("page:input::field")
+            };
+            jsf.ajax.request(document.getElementById("page:input"), event as any, {
+                render: "page:output",
+                execute: "page:input",
+                params: {
+                    "booga2.xxx": "yyy",
+                    "javax.faces.behavior.event": "change",
+                    "booga": "bla"
+                },
+            });
+        } catch (err) {
+            console.error(err);
+            expect(false).to.eq(true);
+        }
+        const requestBody = this.requests[0].requestBody;
+        //We check if the base64 encoded string matches the original
+        expect(requestBody.indexOf("javax.faces.behavior.event")).to.not.eq(-1);
+        expect(requestBody.indexOf("javax.faces.behavior.event=change")).to.not.eq(-1);
+        expect(requestBody.indexOf("page%3Ainput=input_value")).to.not.eq(-1);
+        done();
+    });
+
+
 });