jsf.js_next_gen 4.0.0-RC.2 → 4.0.0-RC.21

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

@@ -20,7 +20,11 @@ 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 {expect} from "chai";
+import prefixPage = StandardInits.prefixEmbeddedPage;
+import prefixEmbeddedPage = StandardInits.prefixEmbeddedPage;
+import HTML_PREFIX_EMBEDDED_BODY = StandardInits.HTML_PREFIX_EMBEDDED_BODY;
+import {it} from "mocha";
 
 describe("test for proper request param patterns identical to the old implementation", function () {
     const UPDATE_INSERT_2 = {
@@ -35,12 +39,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,7 +81,7 @@ 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;
@@ -88,7 +92,7 @@ describe("test for proper request param patterns identical to the old implementa
     });
 
 
-    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();
@@ -100,7 +104,7 @@ describe("test for proper request param patterns identical to the old implementa
     });
 
 
-    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();
@@ -113,7 +117,7 @@ describe("test for proper request param patterns identical to the old implementa
 
     //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();
@@ -123,4 +127,107 @@ describe("test for proper request param patterns identical to the old implementa
 
         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;
+
+        //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,
@@ -39,8 +39,10 @@ let issueStdReq = function (element) {
     faces.ajax.request(element, null, {
         execute: "input_1",
         render: "@form",
-        pass1: "pass1",
-        pass2: "pass2"
+        params: {
+            pass1: "pass1",
+            pass2: "pass2"
+        }
     });
 };
 /**
@@ -103,7 +105,6 @@ describe('Tests on the xhr core when it starts to call the request', function ()
     });
 
     it('it must have the pass through values properly passed', function (done) {
-
         let send = sinon.spy(XMLHttpRequest.prototype, "send");
         try {
             let element = DomQuery.byId("input_2").getAsElem(0).value;
@@ -135,6 +136,35 @@ describe('Tests on the xhr core when it starts to call the request', function ()
         done();
     });
 
+    it('it must handle resetValues properly', function (done) {
+        let send = sinon.spy(XMLHttpRequest.prototype, "send");
+        try {
+            let element = DomQuery.byId("input_2").getAsElem(0).value;
+            faces.ajax.request(element, null, {
+                execute: "input_1",
+                resetValues: true,
+                render: "@form",
+                params: {
+                    pass1: "pass1",
+                    pass2: "pass2"
+                }
+            });
+
+            expect(send.called).to.be.true;
+            let argsVal: any = send.args[0][0];
+            let arsArr = argsVal.split("&");
+            let resultsMap = {};
+            for (let val of arsArr) {
+                let keyVal = val.split("=");
+                resultsMap[keyVal[0]] = keyVal[1];
+            }
+            expect(resultsMap["jakarta.faces.partial.resetValues"]).to.eq("true");
+        } finally {
+            send.restore();
+        }
+        done();
+    });
+
     it('it must have the proper target type', function (done) {
         let send = sinon.spy(XMLHttpRequest.prototype, "send");
         try {
@@ -196,8 +226,10 @@ describe('Tests after core when it hits response', function () {
             faces.ajax.request(element, null, {
                 execute: "input_1",
                 render: "@form",
-                pass1: "pass1",
-                pass2: "pass2",
+                params: {
+                    pass1: "pass1",
+                    pass2: "pass2"
+                },
                 message: "Hello World",
                 onevent: (evt: any) => {
                     localCnt++;
@@ -226,7 +258,8 @@ describe('Tests after core when it hits response', function () {
 
     });
 
-    it('it must have called request and the pass through values must be properly transferred into the context', function (done) {
+    it('it must have called request and the pass through values must be properly transferred ' +
+        'into the context, via the old non spec conform behavior', function (done) {
         let send = sinon.spy(XMLHttpRequest.prototype, "send");
         let globalCnt = 0;
         let localCnt = 0;
@@ -279,6 +312,67 @@ describe('Tests after core when it hits response', function () {
             xhrReq.respond(200, {'Content-Type': 'text/xml'}, STD_XML);
 
 
+        } catch (e) {
+            console.error(e);
+
+        } finally {
+            send.restore();
+        }
+    });
+
+    it('it must have allow array key value pairs as passthroughs', function (done) {
+        let send = sinon.spy(XMLHttpRequest.prototype, "send");
+        let globalCnt = 0;
+        let localCnt = 0;
+        let xhrReq = null;
+
+        try {
+            let element = DomQuery.byId("input_2").getAsElem(0).value;
+            faces.ajax.addOnEvent(() => {
+                globalCnt++;
+            });
+
+
+            faces.ajax.request(element, null, {
+                execute: "input_1",
+                render: "@form",
+                params: [["pass1", "pass1"],
+                    ["pass2", "pass2"]],
+
+                onevent: (evt: any) => {
+                    localCnt++;
+                    if (evt.status == COMPLETE) {
+                        expect(!!xhrReq.responseXML).to.be.true;
+                    }
+                    if (evt.status == SUCCESS) {
+                        expect(this.jsfAjaxResponse.callCount).to.eq(1);
+
+                        expect(this.jsfAjaxResponse.firstCall.args[0] instanceof XMLHttpRequest).to.be.true;
+                        let lastArg = this.jsfAjaxResponse.firstCall.args[1];
+                        expect(lastArg.onevent != null).to.be.true;
+                        expect(lastArg.onevent instanceof Function).to.be.true;
+                        expect(!!lastArg.onError).to.be.false;
+                        expect(lastArg.pass1 == "pass1").to.be.true;
+                        expect(lastArg.pass2 == "pass2").to.be.true;
+                        expect(!!lastArg[P_PARTIAL_SOURCE]).to.be.true;
+                        expect(!!lastArg[P_AJAX]).to.be.true;
+                        expect(!!lastArg[P_EXECUTE]).to.be.true;
+                        expect(!!lastArg[P_RENDER]).to.be.true;
+
+                        expect(this.jsfAjaxResponse.firstCall.args.length).to.eq(2);
+
+                        expect(globalCnt == 2).to.eq(true); //local before global
+                        expect(localCnt == 3).to.eq(true);
+
+                        done();
+                    }
+                }
+            });
+
+            xhrReq = this.requests[0];
+            xhrReq.responsetype = "text/xml";
+            xhrReq.respond(200, {'Content-Type': 'text/xml'}, STD_XML);
+
 
         } catch (e) {
             console.error(e);
@@ -288,6 +382,68 @@ describe('Tests after core when it hits response', function () {
         }
     });
 
+    it('it must have called request and the pass through values must be properly transferred into the context', function (done) {
+        let send = sinon.spy(XMLHttpRequest.prototype, "send");
+        let globalCnt = 0;
+        let localCnt = 0;
+        let xhrReq = null;
+
+        try {
+            let element = DomQuery.byId("input_2").getAsElem(0).value;
+            faces.ajax.addOnEvent(() => {
+                globalCnt++;
+            });
+
+
+            faces.ajax.request(element, null, {
+                execute: "input_1",
+                render: "@form",
+                params: {
+                    pass1: "pass1",
+                    pass2: "pass2",
+                },
+                onevent: (evt: any) => {
+                    localCnt++;
+                    if (evt.status == COMPLETE) {
+                        expect(!!xhrReq.responseXML).to.be.true;
+                    }
+                    if (evt.status == SUCCESS) {
+                        expect(this.jsfAjaxResponse.callCount).to.eq(1);
+
+                        expect(this.jsfAjaxResponse.firstCall.args[0] instanceof XMLHttpRequest).to.be.true;
+                        let lastArg = this.jsfAjaxResponse.firstCall.args[1];
+                        expect(lastArg.onevent != null).to.be.true;
+                        expect(lastArg.onevent instanceof Function).to.be.true;
+                        expect(!!lastArg.onError).to.be.false;
+                        expect(lastArg.pass1 == "pass1").to.be.true;
+                        expect(lastArg.pass2 == "pass2").to.be.true;
+                        expect(!!lastArg[P_PARTIAL_SOURCE]).to.be.true;
+                        expect(!!lastArg[P_AJAX]).to.be.true;
+                        expect(!!lastArg[P_EXECUTE]).to.be.true;
+                        expect(!!lastArg[P_RENDER]).to.be.true;
+
+                        expect(this.jsfAjaxResponse.firstCall.args.length).to.eq(2);
+
+                        expect(globalCnt == 2).to.eq(true); //local before global
+                        expect(localCnt == 3).to.eq(true);
+
+                        done();
+                    }
+                }
+            });
+
+            xhrReq = this.requests[0];
+            xhrReq.responsetype = "text/xml";
+            xhrReq.respond(200, {'Content-Type': 'text/xml'}, STD_XML);
+
+
+        } catch (e) {
+            console.error(e);
+
+        } finally {
+            send.restore();
+        }
+    });
 
 
     it('it must have called onError in the error case', function (done) {
@@ -302,13 +458,15 @@ describe('Tests after core when it hits response', function () {
             faces.ajax.request(element, null, {
                 execute: "input_1",
                 render: "@form",
-                pass1: "pass1",
-                pass2: "pass2",
+                params: {
+                    pass1: "pass1",
+                    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);
@@ -333,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();
+    });
+
+
 });