jsf.js_next_gen 4.1.0-beta.2 → 4.1.0-beta.21

package/src/main/typescript/test/impl/FileUtilsTest.spec.ts

@@ -0,0 +1,126 @@
+/*! 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.
+ */
+// AI-generated: this file was created with assistance from Claude (Anthropic) — see AI_CONTRIBUTIONS.md
+import {describe, it} from "mocha";
+import {expect} from "chai";
+import {Config} from "mona-dish";
+import {decodeEncodedValues, encodeFormData, fixEmptyParameters} from "../../impl/util/FileUtils";
+import {StandardInits} from "../frameworkBase/_ext/shared/StandardInits";
+import {Implementation} from "../../impl/AjaxImpl";
+
+const defaultMyFaces = StandardInits.defaultMyFaces;
+
+// Pure functions — no DOM required.
+describe("decodeEncodedValues", () => {
+
+    it("decodes a single key=value pair", () => {
+        expect(decodeEncodedValues("foo=bar")).to.deep.eq([["foo", "bar"]]);
+    });
+
+    it("splits multiple pairs on &", () => {
+        expect(decodeEncodedValues("a=1&b=2")).to.deep.eq([["a", "1"], ["b", "2"]]);
+    });
+
+    it("returns a one-element array for a key-only segment (no =)", () => {
+        expect(decodeEncodedValues("keyonly")).to.deep.eq([["keyonly"]]);
+    });
+
+    it("decodes percent-encoded characters in key and value", () => {
+        // %20 = space, %21 = !; the & between pairs is literal so both segments are decoded
+        expect(decodeEncodedValues("hello%20world=test%21&a=b"))
+            .to.deep.eq([["hello world", "test!"], ["a", "b"]]);
+    });
+
+    it("splits only on the first = so values containing = are preserved", () => {
+        expect(decodeEncodedValues("key=val=ue")).to.deep.eq([["key", "val=ue"]]);
+    });
+
+    it("filters out blank and whitespace-only segments", () => {
+        expect(decodeEncodedValues("a=1& &b=2")).to.deep.eq([["a", "1"], ["b", "2"]]);
+    });
+
+    it("returns an empty array for an empty string", () => {
+        expect(decodeEncodedValues("")).to.deep.eq([]);
+    });
+});
+
+describe("fixEmptyParameters", () => {
+
+    it("fills both slots with empty arrays when the input is empty", () => {
+        expect(fixEmptyParameters([])).to.deep.eq([[], []]);
+    });
+
+    it("fills the second slot with an empty array when only a key is present", () => {
+        expect(fixEmptyParameters(["key"])).to.deep.eq(["key", []]);
+    });
+
+    it("passes through a two-element array unchanged", () => {
+        expect(fixEmptyParameters(["key", "val"])).to.deep.eq(["key", "val"]);
+    });
+
+    it("passes through arrays of three or more elements unchanged", () => {
+        expect(fixEmptyParameters(["key", "val", "extra"])).to.deep.eq(["key", "val", "extra"]);
+    });
+});
+
+// encodeFormData accesses window.File via ExtDomQuery.global(), so JSDOM is required.
+describe("encodeFormData", () => {
+
+    beforeEach(async function () {
+        return defaultMyFaces().then((close) => {
+            this.closeIt = () => { Implementation.reset(); close(); };
+        });
+    });
+
+    afterEach(function () {
+        this.closeIt();
+    });
+
+    it("returns the defaultStr when the config is absent", () => {
+        expect(encodeFormData(new Config(null), undefined, "FALLBACK")).to.eq("FALLBACK");
+    });
+
+    it("returns empty string as default when no defaultStr is supplied and config is absent", () => {
+        expect(encodeFormData(new Config(null))).to.eq("");
+    });
+
+    it("encodes a single key-value pair", () => {
+        const config = new Config({name: ["Alice"]});
+        expect(encodeFormData(config)).to.eq("name=Alice");
+    });
+
+    it("encodes multiple values for one key as separate params", () => {
+        const config = new Config({color: ["red", "blue"]});
+        expect(encodeFormData(config)).to.eq("color=red&color=blue");
+    });
+
+    it("percent-encodes special characters in keys and values", () => {
+        const config = new Config({"a b": ["x=y"]});
+        expect(encodeFormData(config)).to.eq("a%20b=x%3Dy");
+    });
+
+    it("applies the paramsMapper to rename keys before encoding", () => {
+        const config = new Config({originalKey: ["value"]});
+        const mapper = (_key: string, val: any) => ["renamedKey", val];
+        expect(encodeFormData(config, mapper)).to.eq("renamedKey=value");
+    });
+
+    it("filters out File instances from the encoded output", () => {
+        const file = new (window as any).File(["content"], "upload.txt");
+        const config = new Config({text: ["hello"], upload: [file]});
+        expect(encodeFormData(config)).to.eq("text=hello");
+    });
+});

package/src/main/typescript/test/impl/ImplTest.spec.ts

@@ -20,7 +20,8 @@ import {expect} from 'chai';
 import * as sinon from 'sinon';
 
 import {StandardInits} from "../frameworkBase/_ext/shared/StandardInits";
-import {CTX_PARAM_REQ_PASS_THR, P_EXECUTE, P_RENDER} from "../../impl/core/Const";
+import {CTX_PARAM_REQ_PASS_THR, IDENT_NONE, P_EXECUTE, P_RENDER} from "../../impl/core/Const";
+import {StateHolder} from "../../impl/core/ImplTypes";
 const defaultMyFaces = StandardInits.defaultMyFaces;
 import {_Es2019Array} from "mona-dish";
 
@@ -170,6 +171,22 @@ describe('faces.ajax.request test suite', () => {
 
     })
 
+    it("execute @none must delete P_EXECUTE from the request pass-through context", () => {
+        const addRequestToQueue = sinon.stub(Implementation.queueHandler, "addRequestToQueue");
+        try {
+            DomQuery.byId("input_2").addEventListener("click", (event: Event) => {
+                faces.ajax.request(null, event, {execute: IDENT_NONE, render: IDENT_NONE});
+            }).click();
+
+            expect(addRequestToQueue.called).to.be.true;
+            const context = addRequestToQueue.args[0][2] as Config;
+            // remapDefaultConstants must have deleted P_EXECUTE when execute="@none"
+            expect(context.getIf(CTX_PARAM_REQ_PASS_THR, P_EXECUTE).isAbsent()).to.be.true;
+        } finally {
+            addRequestToQueue.restore();
+        }
+    });
+
     it("sidebehavior chain on undefined must not break the chain only a dedicated false does", function() {
         let called = {};
         window.called = called;
@@ -230,3 +247,60 @@ describe('faces.ajax.request test suite', () => {
 });
 
 
+describe('AjaxImpl.getClientWindow differenceCheck', () => {
+    let oldFlatMap = null;
+
+    beforeEach(async () => {
+        return await StandardInits.defaultMyFaces().then(() => {
+            oldFlatMap = Array.prototype["flatMap"];
+            (window as any)["Es2019Array"] = _Es2019Array;
+            delete Array.prototype["flatMap"];
+        });
+    });
+
+    afterEach(() => {
+        if (oldFlatMap) {
+            Array.prototype["flatMap"] = oldFlatMap;
+            oldFlatMap = null;
+        }
+    });
+
+    it("must throw when two forms have different windowIds", () => {
+        document.body.innerHTML += `
+            <form id="form_wid_a">
+                <input type="hidden" name="jakarta.faces.ClientWindow" value="win1">
+                <input type="hidden" name="jakarta.faces.ViewState" value="vs1">
+            </form>
+            <form id="form_wid_b">
+                <input type="hidden" name="jakarta.faces.ClientWindow" value="win2">
+                <input type="hidden" name="jakarta.faces.ViewState" value="vs2">
+            </form>`;
+
+        expect(() => faces.getClientWindow(document.body)).to.throw();
+    });
+
+    it("must return the windowId when all forms agree", () => {
+        document.body.innerHTML = `
+            <form id="form_wid_ok">
+                <input type="hidden" name="jakarta.faces.ClientWindow" value="samewin">
+                <input type="hidden" name="jakarta.faces.ViewState" value="vs1">
+            </form>`;
+
+        const result = faces.getClientWindow(document.body);
+        expect(result).to.eq("samewin");
+    });
+});
+
+describe('StateHolder.hasNameSpace', () => {
+    it('returns false when id has no namespace prefix', () => {
+        const s = new StateHolder("jakarta.faces.ViewState", "val");
+        expect(s.hasNameSpace).to.be.false;
+        expect(s.nameSpace).to.eq("");
+    });
+
+    it('returns true when id has a namespace prefix', () => {
+        const s = new StateHolder("myForm:jakarta.faces.ViewState", "val");
+        expect(s.hasNameSpace).to.be.true;
+        expect(s.nameSpace).to.eq("myForm");
+    });
+});

package/src/main/typescript/test/impl/ResponseDataResolverTest.spec.ts

@@ -0,0 +1,62 @@
+/*! 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.
+ */
+// AI-generated: this file was created with assistance from Claude (Anthropic) — see AI_CONTRIBUTIONS.md
+import {describe, it} from "mocha";
+import {expect} from "chai";
+import {resolveContexts} from "../../impl/xhrCore/ResponseDataResolver";
+import {
+    CTX_PARAM_MF_INTERNAL,
+    DEFERRED_HEAD_INSERTS,
+    UPDATE_ELEMS,
+    UPDATE_FORMS
+} from "../../impl/core/Const";
+
+describe("resolveContexts", () => {
+
+    it("creates a fresh internal context when none is present in the external context", () => {
+        const {externalContext, internalContext} = resolveContexts({});
+
+        expect(internalContext.isPresent(),
+            "internalContext must be present even when none was supplied").to.be.true;
+        expect(internalContext.getIf(DEFERRED_HEAD_INSERTS).value,
+            "DEFERRED_HEAD_INSERTS must be initialised to an empty array").to.deep.eq([]);
+        expect(internalContext.getIf(UPDATE_FORMS).value,
+            "UPDATE_FORMS must be initialised to an empty array").to.deep.eq([]);
+        expect(internalContext.getIf(UPDATE_ELEMS).value,
+            "UPDATE_ELEMS must be initialised to an empty array").to.deep.eq([]);
+    });
+
+    it("reuses the existing internal context when one is present in the external context", () => {
+        // assign/getIf in mona-dish treat dot-strings as flat keys, not nested paths.
+        // CTX_PARAM_MF_INTERNAL = "myfaces.internal" is stored as a literal flat key.
+        const context = {[CTX_PARAM_MF_INTERNAL]: {existingKey: "existingValue"}};
+        const {externalContext, internalContext} = resolveContexts(context);
+
+        expect(internalContext.getIf("existingKey").value,
+            "existing internal context values must be preserved").to.eq("existingValue");
+        expect(internalContext.getIf(DEFERRED_HEAD_INSERTS).value,
+            "DEFERRED_HEAD_INSERTS must be initialised even when reusing an existing context").to.deep.eq([]);
+        expect(internalContext.getIf(UPDATE_FORMS).value).to.deep.eq([]);
+        expect(internalContext.getIf(UPDATE_ELEMS).value).to.deep.eq([]);
+    });
+
+    it("wraps the original object as the external context", () => {
+        const context = {source: "button1"};
+        const {externalContext} = resolveContexts(context);
+
+        expect(externalContext.getIf("source").value).to.eq("button1");
+    });
+});

package/src/main/typescript/test/impl/util/ExtDomQueryTest.spec.ts

@@ -17,10 +17,11 @@
 import {afterEach, describe, it} from 'mocha';
 import {expect} from 'chai';
 
-import {ExtDomQuery} from "../../../impl/util/ExtDomQuery";
+import {ExtConfig, ExtDomQuery} from "../../../impl/util/ExtDomQuery";
 import {StandardInits} from "../../frameworkBase/_ext/shared/StandardInits";
 const defaultMyFaces = StandardInits.defaultMyFaces;
 import Sinon from "sinon";
+import {Implementation} from "../../../impl/AjaxImpl";
 
 declare var faces: any;
 let oldProjectStage = null;
@@ -65,4 +66,93 @@ describe('ExtDomQuery test suite', () => {
         }
         done();
     });
+
+    it('ExtDomQuery.nonce falls back to finding nonce on a faces script tag in the DOM', () => {
+        const script = document.createElement("script");
+        // /javax.faces.resource/jsf.js matches IS_FACES_SOURCE pattern \/javax\.faces\.resource.*\/jsf\.js.*
+        script.setAttribute("src", "/javax.faces.resource/jsf.js");
+        script.setAttribute("nonce", "test-nonce-abc");
+        document.head.appendChild(script);
+        try {
+            const nonce = new ExtDomQuery(document.body).nonce;
+            expect(nonce.value).to.eq("test-nonce-abc");
+        } finally {
+            document.head.removeChild(script);
+        }
+    });
+
+    it('ExtDomQuery.runHeadInserts handles text nodes (no tagName) without throwing', () => {
+        const text = document.createTextNode("inline text");
+        expect(() => new ExtDomQuery(text as any).runHeadInserts()).not.to.throw();
+    });
+
+    it('runHeadInserts with suppressDoubleIncludes=false inserts duplicate link resources', () => {
+        const href = "/test-res-no-dedup.css";
+        const existing = document.createElement("link");
+        existing.setAttribute("href", href);
+        document.head.appendChild(existing);
+
+        const before = document.head.querySelectorAll(`link[href="${href}"]`).length;
+
+        const dup = document.createElement("link");
+        dup.setAttribute("href", href);
+        new ExtDomQuery(dup as any).runHeadInserts(false);
+
+        expect(document.head.querySelectorAll(`link[href="${href}"]`).length).to.be.gt(before);
+    });
+
+    it('runHeadInserts with suppressDoubleIncludes=true skips duplicate link resources', () => {
+        const href = "/test-res-with-dedup.css";
+        const existing = document.createElement("link");
+        existing.setAttribute("href", href);
+        document.head.appendChild(existing);
+
+        const before = document.head.querySelectorAll(`link[href="${href}"]`).length;
+
+        const dup = document.createElement("link");
+        dup.setAttribute("href", href);
+        new ExtDomQuery(dup as any).runHeadInserts(true);
+
+        expect(document.head.querySelectorAll(`link[href="${href}"]`).length).to.eq(before);
+    });
+});
+
+describe('ExtConfig', () => {
+    let closeIt: () => void;
+
+    beforeEach(async function () {
+        return defaultMyFaces().then((close) => {
+            closeIt = () => { Implementation.reset(); close(); };
+        });
+    });
+
+    afterEach(function () { closeIt(); });
+
+    it('append stores a value under the given key', () => {
+        const config = new ExtConfig({});
+        config.append("items").value = ["first"];
+        expect(config.getIf("items").value).to.deep.eq(["first"]);
+    });
+
+    it('appendIf stores a value when condition is true', () => {
+        const config = new ExtConfig({});
+        config.appendIf(true, "key").value = ["yes"];
+        expect(config.getIf("key").value).to.deep.eq(["yes"]);
+    });
+
+    it('appendIf is a no-op when condition is false', () => {
+        const config = new ExtConfig({existing: "val"});
+        config.appendIf(false, "existing");
+        expect(config.getIf("existing").value).to.eq("val");
+    });
+
+    it('deepCopy produces an independent copy', () => {
+        const config = new ExtConfig({name: "Alice"});
+        const copy = config.deepCopy;
+        expect(copy.getIf("name").value).to.eq("Alice");
+        // mutating the copy must not affect the original
+        copy.assign("name").value = "Bob";
+        expect(config.getIf("name").value).to.eq("Alice");
+    });
+
 });

package/src/main/typescript/test/impl/util/ExtLangTest.spec.ts

@@ -0,0 +1,110 @@
+/*! 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.
+ */
+// AI-generated: this file was created with assistance from Claude (Anthropic) — see AI_CONTRIBUTIONS.md
+
+import {describe} from "mocha";
+import {expect} from "chai";
+import * as sinon from "sinon";
+import {Config} from "mona-dish";
+import {ExtLang} from "../../../impl/util/Lang";
+import {StandardInits} from "../../frameworkBase/_ext/shared/StandardInits";
+
+describe("ExtLang", function () {
+
+    beforeEach(function () {
+        return StandardInits.defaultMyFaces().then((close) => {
+            this.closeIt = close;
+        });
+    });
+
+    afterEach(function () {
+        this.closeIt();
+    });
+
+    it("must resolve messages with default fallback and template replacement", function () {
+        expect(ExtLang.getMessage("missing.key", "Hello {0}", "World")).to.eq("Hello World");
+        expect(ExtLang.getMessage("missing.key")).to.eq("missing.key");
+    });
+
+    it("must return a message string when the key exists in Messages", function () {
+        // MSG_TEST is defined in Messages.ts as "Testmessage" — covers the left branch of ?? defaultMessage ?? key
+        expect(ExtLang.getMessage("MSG_TEST")).to.eq("Testmessage");
+    });
+
+    it("must read global and local myfaces config with local priority", function () {
+        window.myfaces.config = {...window.myfaces.config, delay: 50, timeout: 100};
+
+        expect(ExtLang.getGlobalConfig("delay", 0)).to.eq(50);
+        expect(ExtLang.getGlobalConfig("unknown", 7)).to.eq(7);
+
+        const localOptions = new Config({myfaces: {config: {delay: 10}}});
+
+        expect(ExtLang.getLocalOrGlobalConfig(localOptions, "delay", 0)).to.eq(10);
+        expect(ExtLang.getLocalOrGlobalConfig(localOptions, "timeout", 0)).to.eq(100);
+        expect(ExtLang.getLocalOrGlobalConfig(localOptions, "unknown", 7)).to.eq(7);
+    });
+
+    it("must convert associative objects to tuples and collect tuples back into an object", function () {
+        const tuples = ExtLang.ofAssoc({one: 1, two: 2});
+
+        expect(tuples).to.deep.eq([["one", 1], ["two", 2]]);
+        expect(tuples.reduce(ExtLang.collectAssoc, {})).to.deep.eq({one: 1, two: 2});
+    });
+
+    it("must provide fail-safe resolving and execution helpers", function () {
+        let executed = false;
+
+        expect(ExtLang.failSaveResolve(() => "ok").value).to.eq("ok");
+        expect(ExtLang.failSaveResolve(() => { throw new Error("boom"); }, "fallback").isAbsent()).to.be.true;
+        expect(() => ExtLang.failSaveExecute(() => { executed = true; })).not.to.throw();
+        expect(() => ExtLang.failSaveExecute(() => { throw new Error("boom"); })).not.to.throw();
+        expect(executed).to.be.true;
+    });
+
+    it("must resolve forms from direct form, form attribute and parent form", function () {
+        document.body.innerHTML = `
+            <form id="outer">
+                <button id="nested"></button>
+            </form>
+            <form id="target"></form>
+            <button id="detached" form="target"></button>`;
+
+        expect(ExtLang.getForm(document.getElementById("outer")!).id.value).to.eq("outer");
+        expect(ExtLang.getForm(document.getElementById("detached")!).id.value).to.eq("target");
+        expect(ExtLang.getForm(document.getElementById("nested")!).id.value).to.eq("outer");
+    });
+
+    it("must debounce repeated calls by key", function () {
+        const clock = sinon.useFakeTimers();
+        let callCount = 0;
+
+        try {
+            ExtLang.debounce("key", () => { callCount++; }, 50);
+            ExtLang.debounce("key", () => { callCount++; }, 50);
+
+            clock.tick(49);
+            expect(callCount).to.eq(0);
+
+            clock.tick(1);
+            expect(callCount).to.eq(1);
+
+            ExtLang.debounce("immediate", () => { callCount++; }, 0);
+            expect(callCount).to.eq(2);
+        } finally {
+            clock.restore();
+        }
+    });
+});

package/src/main/typescript/test/impl/util/HiddenInputBuilderTest.spec.ts

@@ -0,0 +1,74 @@
+/*! 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.
+ */
+// AI-generated: this file was created with assistance from Claude (Anthropic) — see AI_CONTRIBUTIONS.md
+
+import {describe} from "mocha";
+import {expect} from "chai";
+import {DQ} from "mona-dish";
+import {Implementation} from "../../../impl/AjaxImpl";
+import {HiddenInputBuilder} from "../../../impl/util/HiddenInputBuilder";
+import {StandardInits} from "../../frameworkBase/_ext/shared/StandardInits";
+
+describe("HiddenInputBuilder", function () {
+
+    beforeEach(function () {
+        return StandardInits.defaultMyFaces().then((close) => {
+            this.closeIt = () => {
+                Implementation.reset();
+                close();
+            };
+        });
+    });
+
+    afterEach(function () {
+        this.closeIt();
+    });
+
+    it("must build and append the next ViewState hidden input for a named view root", function () {
+        document.body.innerHTML = `
+            <form id="viewroot_1:form1">
+                <input type="hidden" id="viewroot_1:jakarta.faces.ViewState:2" name="viewroot_1:jakarta.faces.ViewState" value="old">
+            </form>`;
+
+        const form = DQ.byId("viewroot_1:form1");
+        const hiddenInput = new HiddenInputBuilder("input[name*='jakarta.faces.ViewState']")
+            .withNamingContainerId("viewroot_1")
+            .withNamedViewRoot(true)
+            .withParent(form)
+            .build();
+
+        hiddenInput.val = "new";
+
+        expect(hiddenInput.id.value).to.eq("viewroot_1:jakarta.faces.ViewState:3");
+        expect(hiddenInput.name.value).to.eq("viewroot_1:jakarta.faces.ViewState");
+        expect(hiddenInput.val).to.eq("new");
+        expect(form.querySelectorAll("#viewroot_1\\:jakarta\\.faces\\.ViewState\\:3").isPresent()).to.be.true;
+    });
+
+    it("must build ClientWindow without prefixing the name for a non-named view root", function () {
+        document.body.innerHTML = `<form id="form1"></form>`;
+
+        const hiddenInput = new HiddenInputBuilder("input[name*='jakarta.faces.ClientWindow']")
+            .withNamingContainerId("viewroot_1")
+            .withNamedViewRoot(false)
+            .withParent(DQ.byId("form1"))
+            .build();
+
+        expect(hiddenInput.id.value).to.eq("viewroot_1:jakarta.faces.ClientWindow:1");
+        expect(hiddenInput.name.value).to.eq("jakarta.faces.ClientWindow");
+        expect(DQ.byId("form1").querySelectorAll("[name='jakarta.faces.ClientWindow']").isPresent()).to.be.true;
+    });
+});

package/src/main/typescript/test/myfaces/OamSubmit.spec.ts

@@ -130,5 +130,65 @@ describe('Tests on the xhr core when it starts to call the request', function ()
 
     })
 
+    it('onsubmit must receive null for compatibility', function () {
+        let FORM_ID = "blarg";
+        let form = DomQuery.byId(FORM_ID);
+        const onsumbit = Sinon.spy(() => false);
+        const submit_spy = Sinon.spy(() => {
+        });
+
+        (form.value.value as any).onsubmit = onsumbit;
+        (form.value.value as any).submit = submit_spy;
+
+        submitForm(FORM_ID, 'mylink', 'target1', {
+            booga1: "val_booga1",
+            booga2: "val_booga2"
+        });
+
+        expect(onsumbit.calledOnce).to.eq(true);
+        expect(onsumbit.firstCall.args.length).to.eq(1);
+        expect((onsumbit.firstCall.args as any[])[0]).to.eq(null);
+        expect(submit_spy.called).to.eq(false);
+    })
+
+    it('setHiddenInput must update the value when the field already exists', function () {
+        let FORM_ID = "blarg";
+        setHiddenInput(FORM_ID, "existing_field", "first_value");
+        setHiddenInput(FORM_ID, "existing_field", "updated_value");
+        const inputs = DomQuery.byId(FORM_ID).querySelectorAll("input[name='existing_field']");
+        expect(inputs.length).to.eq(1, "must not create a duplicate input");
+        expect(inputs.inputValue.value).to.eq("updated_value", "must update the value in-place");
+    });
+
+    it('clearHiddenInput must not throw when the field does not exist', function () {
+        let FORM_ID = "blarg";
+        expect(() => clearHiddenInput(FORM_ID, "nonexistent_field")).not.to.throw();
+    });
+
+    it('submitForm must work with array-style params', function () {
+        let FORM_ID = "blarg";
+        let form = DomQuery.byId(FORM_ID);
+        const submit_spy = Sinon.spy(() => {});
+        (form.value.value as any).submit = submit_spy;
+
+        submitForm(FORM_ID, 'mylink', null, [["arrKey1", "arrVal1"], ["arrKey2", "arrVal2"]]);
+
+        expect(submit_spy.called).to.eq(true);
+        form = DomQuery.byId(FORM_ID);
+        expect(form.querySelectorAll("input[name='arrKey1']").isAbsent()).to.eq(true, "params must be cleaned up after submit");
+        expect(form.querySelectorAll("input[name='arrKey2']").isAbsent()).to.eq(true, "params must be cleaned up after submit");
+    });
+
+    it('submitForm must work when params is null', function () {
+        let FORM_ID = "blarg";
+        let form = DomQuery.byId(FORM_ID);
+        const submit_spy = Sinon.spy(() => {});
+        (form.value.value as any).submit = submit_spy;
+
+        submitForm(FORM_ID, null, null, null);
+
+        expect(submit_spy.called).to.eq(true);
+    });
+
     // further tests will follow if needed, for now the namespace must be restored
-});
+});