jsf.js_next_gen 4.0.0-beta-23 → 4.0.1-alpha.0

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

@@ -20,10 +20,10 @@ 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,
+    P_AJAX_SOURCE,
     P_RENDER,
     P_VIEWSTATE,
     P_WINDOW_ID,
@@ -39,10 +39,35 @@ let issueStdReq = function (element) {
     faces.ajax.request(element, null, {
         execute: "input_1",
         render: "@form",
-        pass1: "pass1",
-        pass2: "pass2"
+        params: {
+            pass1: "pass1",
+            pass2: "pass2"
+        }
     });
 };
+
+
+let issueStdPPSReq = function (element) {
+    faces.ajax.request(element, null, {
+        execute: "input_1",
+        render: "@form",
+        /*
+        * myfaces is the extension placeholder, atm only pps is used
+        * which was the most useful extension in our legacy codebase
+        */
+        myfaces: {
+            pps: true
+        },
+        /*
+         * params is the spec conform way to pass additional request paramerters
+         */
+        params: {
+            pass1: "pass1",
+            pass2: "pass2"
+        }
+    });
+};
+
 /**
  * specialized tests testing the xhr core behavior when it hits the xmlHttpRequest object
  */
@@ -103,7 +128,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;
@@ -118,13 +142,16 @@ describe('Tests on the xhr core when it starts to call the request', function ()
                 resultsMap[keyVal[0]] = keyVal[1];
             }
 
+            // normal request, all issuing form must be encoded!
+            expect(!!(resultsMap?.["input_2_text"] ?? false)).to.eq(true);
+            expect(!!(resultsMap?.["input_1"] ?? false)).to.eq(true);
             expect(resultsMap["pass1"]).to.eq("pass1");
             expect(resultsMap["pass2"]).to.eq("pass2");
             expect(!!resultsMap["render"]).to.be.false;
             expect(!!resultsMap["execute"]).to.be.false;
             expect(P_WINDOW_ID in resultsMap).to.be.false;
             expect(P_VIEWSTATE in resultsMap).to.be.true;
-            expect(resultsMap[P_PARTIAL_SOURCE]).to.eq("input_2");
+            expect(resultsMap[P_AJAX_SOURCE]).to.eq("input_2");
             expect(resultsMap[P_AJAX]).to.eq("true");
             expect(resultsMap[P_RENDER]).to.eq("blarg");
             expect(resultsMap[P_EXECUTE]).to.eq("input_1%20input_2");
@@ -135,6 +162,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,16 +252,24 @@ 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++;
                 }
             });
 
             let xhrReq = this.requests[0];
+            let requestBody = xhrReq.requestBody.split("&");
 
             xhrReq.respond(200, {'Content-Type': 'text/xml'}, STD_XML);
+            expect(requestBody.indexOf("pass1=pass1")).not.to.eq(-1);
+            expect(requestBody.indexOf("pass2=pass2")).not.to.eq(-1);
+            expect(requestBody.indexOf("message=Hello%20World")).not.to.eq(-1);
+
             expect(this.jsfAjaxResponse.callCount).to.eq(1);
             //success ommitted due to fake response
             expect(globalCnt == 3).to.eq(true);
@@ -220,7 +284,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;
@@ -253,7 +318,7 @@ describe('Tests after core when it hits response', function () {
                         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_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;
@@ -273,6 +338,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_AJAX_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);
@@ -282,6 +408,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_AJAX_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) {
@@ -289,20 +477,23 @@ describe('Tests after core when it hits response', function () {
 
         let send = sinon.spy(XMLHttpRequest.prototype, "send");
         let xhrReq = null;
-
+        const oldErr = console.error;
         try {
             let errorCnt = 0;
+
             let element = DomQuery.byId("input_2").getAsElem(0).value;
             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);
@@ -310,6 +501,8 @@ describe('Tests after core when it hits response', function () {
                 },
                 onevent: (evt: any) => {
                     if (evt.status == COMPLETE) {
+                        console.error = () => {
+                        };
                         throw Error("This error is wanted, ignore the log");
                     }
                 }
@@ -320,12 +513,124 @@ describe('Tests after core when it hits response', function () {
             xhrReq.respond(200, {'Content-Type': 'text/xml'}, STD_XML);
 
         } catch (e) {
+            if (e.message.indexOf("This error is wanted") != -1) {
+                return;
+            }
             console.error(e);
 
         } finally {
+            console.error = oldErr;
             send.restore();
         }
 
     });
+
+    // 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")
+    });
+
+    it("must have a proper working myfaces.pps = true, partial page submit", function (done) {
+        /**
+         * derived from the passthrough test
+         */
+        let send = sinon.spy(XMLHttpRequest.prototype, "send");
+        try {
+            //we only issue input 1
+            let element = DomQuery.byId("input_1").getAsElem(0).value;
+            issueStdPPSReq(element);
+
+            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?.["input_2_text"] ?? false).to.eq(false);
+            expect(!!(resultsMap?.["input_1"] ?? false)).to.eq(true);
+            expect(resultsMap["pass1"]).to.eq("pass1");
+            expect(resultsMap["pass2"]).to.eq("pass2");
+            expect(!!resultsMap["render"]).to.be.false;
+            expect(!!resultsMap["execute"]).to.be.false;
+            expect(P_WINDOW_ID in resultsMap).to.be.false;
+            expect(P_VIEWSTATE in resultsMap).to.be.true;
+            expect(resultsMap[P_AJAX_SOURCE]).to.eq("input_1");
+            expect(resultsMap[P_AJAX]).to.eq("true");
+            expect(resultsMap[P_RENDER]).to.eq("blarg");
+            expect(resultsMap[P_EXECUTE]).to.eq("input_1");
+
+
+            // TODO the request map only has the params and input1_ and input_2 passed no matter now many other values
+            // we might have to add some input elements into the form which are filetered out
+        } finally {
+            send.restore();
+        }
+        done();
+    });
+
+
 });
 

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;
@@ -323,7 +324,7 @@ describe('Tests after core when it hits response', function () {
 
         let send = sinon.spy(XMLHttpRequest.prototype, "send");
         let xhrReq = null;
-
+        let oldErr = console.error;
         try {
             let element = DomQuery.byId("input_2").getAsElem(0).value;
             jsf.ajax.request(element, null, {
@@ -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);
@@ -343,6 +344,7 @@ describe('Tests after core when it hits response', function () {
                 },
                 onevent: (evt: any) => {
                     if (evt.status == COMPLETE) {
+                        console.error = () => {};
                         throw Error("This error is wanted, ignore the log");
                     }
                 }
@@ -353,12 +355,51 @@ describe('Tests after core when it hits response', function () {
             xhrReq.respond(200, {'Content-Type': 'text/xml'}, STD_XML);
 
         } catch (e) {
+            if(e.message.indexOf("This error is wanted") != -1) {
+                return;
+            }
             console.error(e);
 
         } finally {
+            console.error = oldErr;
             send.restore();
         }
 
     });
+
+    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();
+    });
+
+
 });