jsf.js_next_gen 4.0.0-beta-23 → 4.0.0

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

@@ -0,0 +1,203 @@
+/*! Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {describe, it} from "mocha";
+import * as sinon from "sinon";
+import {expect} from "chai";
+import {StandardInits} from "../frameworkBase/_ext/shared/StandardInits";
+import {DomQuery, DQ$, Stream} from "mona-dish";
+import {
+    $nsp,
+    COMPLETE,
+    P_AJAX,
+    P_EXECUTE,
+    P_PARTIAL_SOURCE,
+    P_RENDER,
+    P_VIEWSTATE,
+    P_WINDOW_ID,
+    SUCCESS
+} from "../../impl/core/Const";
+import defaultMyFaces = StandardInits.defaultMyFaces;
+import STD_XML = StandardInits.STD_XML;
+import defaultMyFacesNamespaces = StandardInits.defaultMyFacesNamespaces;
+import {escape} from "querystring";
+
+declare var faces: any;
+declare var Implementation: any;
+
+let issueStdReq = function (element) {
+    faces.ajax.request(element, null, {
+        execute: "input_1",
+        render: "@form",
+        params: {
+            pass1: "pass1",
+            pass2: "pass2"
+        }
+    });
+};
+
+describe('Namespacing tests', function () {
+    beforeEach(async function () {
+
+        let waitForResult = defaultMyFacesNamespaces();
+
+        return waitForResult.then((close) => {
+
+            this.xhr = sinon.useFakeXMLHttpRequest();
+            this.requests = [];
+            this.xhr.onCreate = (xhr) => {
+                this.requests.push(xhr);
+            };
+            (<any>global).XMLHttpRequest = this.xhr;
+            window.XMLHttpRequest = this.xhr;
+
+            this.jsfAjaxResponse = sinon.spy((<any>global).faces.ajax, "response");
+
+            this.closeIt = () => {
+                (<any>global).XMLHttpRequest = window.XMLHttpRequest = this.xhr.restore();
+                this.jsfAjaxResponse.restore();
+                Implementation.reset();
+                close();
+            }
+        });
+    });
+
+    afterEach(function () {
+        this.closeIt();
+    });
+
+    it('must send the element identifiers properly encoded', function () {
+        let send = sinon.spy(XMLHttpRequest.prototype, "send");
+        try {
+            global["debug3"] = true;
+            faces.ajax.request(document.getElementById("jd_0:input_2"), null, {
+                execute: ":input_1",
+                render: ":blarg :input_2",
+                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["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(escape("jd_0:input_2"));
+            expect(resultsMap[P_AJAX]).to.eq("true");
+            expect(resultsMap[P_RENDER]).to.eq(escape("jd_0:blarg jd_0:input_2"));
+            expect(resultsMap[P_EXECUTE]).to.eq(escape("jd_0:input_1 jd_0:input_2"));
+        } finally {
+            send.restore();
+        }
+    })
+
+    it('must send the element identifiers properly encoded 2', function () {
+        let send = sinon.spy(XMLHttpRequest.prototype, "send");
+        try {
+            faces.ajax.request(document.getElementById("jd_0:input_2"), null, {
+                execute: "jd_0:input_1",
+                render: ":blarg jd_0:input_2",
+                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["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(escape("jd_0:input_2"));
+            expect(resultsMap[P_AJAX]).to.eq("true");
+            expect(resultsMap[P_RENDER]).to.eq(escape("jd_0:blarg jd_0:input_2"));
+            expect(resultsMap[P_EXECUTE]).to.eq(escape("jd_0:input_1 jd_0:input_2"));
+        } finally {
+            send.restore();
+        }
+    })
+
+
+    it('must get name prefixed viewstate properly', function () {
+        let send = sinon.spy(XMLHttpRequest.prototype, "send");
+        try {
+            DQ$(`[name*='${P_VIEWSTATE}']`).attr("name").value = `jd_0:${P_VIEWSTATE}`;
+            DQ$(`[name*='${P_VIEWSTATE}']`).val = "booga";
+
+            faces.ajax.request(document.getElementById("jd_0:input_2"), null, {
+                execute: "jd_0:input_1",
+                render: ":blarg jd_0:input_2",
+                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[unescape(keyVal[0])] = unescape(keyVal[1]);
+            }
+            const NAMING_CONTAINER_PREF = "jd_0:";
+            expect(resultsMap[NAMING_CONTAINER_PREF + "pass1"]).to.eq("pass1");
+            expect(resultsMap[NAMING_CONTAINER_PREF + "pass2"]).to.eq("pass2");
+            expect(!!resultsMap["render"]).to.be.false;
+            expect(!!resultsMap["execute"]).to.be.false;
+
+            let hasWindowdId = Stream.ofAssoc(resultsMap).filter(data => data[0].indexOf(P_WINDOW_ID) != -1).first().isPresent();
+            let hasViewState = Stream.ofAssoc(resultsMap).filter(data => data[0].indexOf(P_VIEWSTATE) != -1).first().isPresent();
+
+            expect(hasWindowdId).to.be.false;
+            expect(hasViewState).to.be.true;
+
+            let viewState = Stream.ofAssoc(resultsMap).filter(data => data[0].indexOf(P_VIEWSTATE) != -1).map(item => item[1]).first().value;
+
+            expect(viewState).to.eq("booga");
+            expect(resultsMap[NAMING_CONTAINER_PREF + P_PARTIAL_SOURCE]).to.eq("jd_0:input_2");
+            expect(resultsMap[NAMING_CONTAINER_PREF + P_AJAX]).to.eq("true");
+            expect(resultsMap[NAMING_CONTAINER_PREF + P_RENDER]).to.eq("jd_0:blarg jd_0:input_2");
+            expect(resultsMap[NAMING_CONTAINER_PREF + P_EXECUTE]).to.eq("jd_0:input_1 jd_0:input_2");
+        } finally {
+            send.restore();
+        }
+    })
+
+});

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

@@ -0,0 +1,177 @@
+/*! Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {describe} from "mocha";
+import * as sinon from "sinon";
+import {Implementation} from "../../impl/AjaxImpl";
+import {StandardInits} from "../frameworkBase/_ext/shared/StandardInits";
+import defaultMyFaces = StandardInits.defaultMyFaces;
+import {DQ, DQ$} from "mona-dish";
+import {expect} from "chai";
+
+describe('Tests for the MyFaces specifig oam submit', function () {
+
+    beforeEach(async function () {
+
+        let waitForResult = defaultMyFaces();
+
+        return waitForResult.then((close) => {
+
+            this.xhr = sinon.useFakeXMLHttpRequest();
+            this.requests = [];
+            this.xhr.onCreate = (xhr) => {
+                this.requests.push(xhr);
+            };
+            (<any>global).XMLHttpRequest = this.xhr;
+            window.XMLHttpRequest = this.xhr;
+
+            this.jsfAjaxResponse = sinon.spy((<any>global).faces.ajax, "response");
+
+            this.closeIt = () => {
+                (<any>global).XMLHttpRequest = window.XMLHttpRequest = this.xhr.restore();
+                this.jsfAjaxResponse.restore();
+                Implementation.reset();
+                close();
+            }
+        });
+    });
+
+    afterEach(function () {
+        this.closeIt();
+    });
+
+    it(("must handle oam submit correctly, tuples"), (done) => {
+
+        let options = [["booga1", "value1"], ["booga2", "value2"]];
+
+        (DQ.byId("blarg")
+            .getAsElem(0).value as HTMLFormElement).onsubmit = (evt) => {
+            expect(DQ$("#blarg #booga1").inputValue.value).to.eq("value1");
+            expect(DQ$("#blarg #booga2").inputValue.value).to.eq("value2");
+            done();
+            return false;
+        };
+
+        myfaces.oam.submitForm("blarg", null, null, options);
+
+    });
+    it(("must handle oam submit correctly, associative array"), (done) => {
+
+        let options = {"booga1": "value1", "booga2": "value2"};
+
+        (DQ.byId("blarg")
+            .getAsElem(0).value as HTMLFormElement).onsubmit = (evt) => {
+            expect(DQ$("#blarg #booga1").inputValue.value).to.eq("value1");
+            expect(DQ$("#blarg #booga2").inputValue.value).to.eq("value2");
+            done();
+            return false;
+        };
+
+        myfaces.oam.submitForm("blarg", null, null, options);
+
+    });
+
+    it(("all hidden inputs must be cleared post submit"), (done) => {
+
+        let options = {"booga1": "value1", "booga2": "value2"};
+
+        (DQ.byId("blarg")
+            .getAsElem(0).value as HTMLFormElement).onsubmit = (evt) => {
+            expect(DQ$("#blarg #booga1").length).to.eq(1);
+            expect(DQ$("#blarg #booga2").length).to.eq(1);
+            return false;
+        };
+
+        myfaces.oam.submitForm("blarg", null, null, options);
+
+        expect(DQ$("#blarg #booga1").length).to.eq(0);
+        expect(DQ$("#blarg #booga2").length).to.eq(0);
+        done();
+    });
+
+    it(("must handle linkid correctly, associative array"), (done) => {
+
+        let options = {"booga1": "value1", "booga2": "value2"};
+
+        (DQ.byId("blarg")
+            .getAsElem(0).value as HTMLFormElement).onsubmit = (evt) => {
+            expect(DQ.byId(`blarg:_idcl`).inputValue.value).to.eq("bla");
+            done();
+            return false;
+        };
+
+        myfaces.oam.submitForm("blarg", "bla", null, options);
+
+    });
+
+    it(("must handle target correctly, associative array"), (done) => {
+
+        let options = {"booga1": "value1", "booga2": "value2"};
+        (DQ.byId("blarg")
+            .getAsElem(0).value as HTMLFormElement).onsubmit = (evt) => {
+            expect(DQ$(`#blarg`).attr("target").value).to.eq("target1");
+            done();
+            return false;
+        };
+        myfaces.oam.submitForm("blarg", "bla", "target1", options);
+
+    });
+
+    it(("must handle limited parameters"), (done) => {
+
+        (DQ.byId("blarg")
+            .getAsElem(0).value as HTMLFormElement).onsubmit = (evt) => {
+            expect(DQ.byId(`blarg:_idcl`).inputValue.value).to.eq("bla");
+            done();
+            return false;
+        };
+        try {
+        myfaces.oam.submitForm("blarg", "bla");
+        } catch(e) {
+            done(e);
+        }
+
+    });
+    it(("must handle limited parameters 2"), (done) => {
+
+        (DQ.byId("blarg")
+            .getAsElem(0).value as HTMLFormElement).onsubmit = (evt) => {
+            expect(DQ.byId(`blarg:_idcl`).inputValue.value).to.eq("bla");
+            done();
+            return false;
+        };
+        try {
+            myfaces.oam.submitForm("blarg", "bla", null);
+        } catch(e) {
+            done(e);
+        }
+    });
+    it(("must handle limited parameters 3"), (done) => {
+
+        (DQ.byId("blarg")
+            .getAsElem(0).value as HTMLFormElement).onsubmit = (evt) => {
+            expect(DQ.byId(`blarg:_idcl`).inputValue.value).to.eq("bla");
+            done();
+            return false;
+        };
+        try {
+            myfaces.oam.submitForm("blarg", "bla", null, null);
+        } catch(e) {
+            done(e);
+        }
+    });
+
+});

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();
+    });
+
 });