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

package/src/main/typescript/test/queue/AsynchronousQueueTest.spec.ts

@@ -25,6 +25,44 @@ import {StandardInits} from "../frameworkBase/_ext/shared/StandardInits";
 import {Implementation} from "../../impl/AjaxImpl";
 const defaultMyFaces = StandardInits.defaultMyFaces;
 import {XhrQueueController} from "../../impl/util/XhrQueueController";
+import {AsyncRunnable, IAsyncRunnable} from "../../impl/util/AsyncRunnable";
+
+class ControlledRunnable implements IAsyncRunnable<boolean> {
+    started = 0;
+    private thenHandlers: Array<(data: any) => any> = [];
+    private catchHandlers: Array<(data: any) => any> = [];
+
+    start(): void {
+        this.started++;
+    }
+
+    cancel(): void {
+    }
+
+    then(func: (data: any) => any): IAsyncRunnable<boolean> {
+        this.thenHandlers.push(func);
+        return this;
+    }
+
+    catch(func: (data: any) => any): IAsyncRunnable<boolean> {
+        this.catchHandlers.push(func);
+        return this;
+    }
+
+    finally(func: () => void): IAsyncRunnable<boolean> {
+        this.thenHandlers.push(func);
+        this.catchHandlers.push(func);
+        return this;
+    }
+
+    resolve(): void {
+        this.thenHandlers.forEach(handler => handler(true));
+    }
+
+    reject(): void {
+        this.catchHandlers.forEach(handler => handler(false));
+    }
+}
 
 describe('Asynchronous Queue tests', () => {
 
@@ -104,5 +142,156 @@ describe('Asynchronous Queue tests', () => {
 
     });
 
-    //TODO error test?
-});
+    it('must not start a queued entry while another task is running', function () {
+        const queue = new XhrQueueController();
+        const first = new ControlledRunnable();
+        const second = new ControlledRunnable();
+
+        queue.enqueue(first);
+        queue.enqueue(second);
+
+        expect(first.started).to.eq(1);
+        expect(second.started).to.eq(0);
+        expect(queue.isEmpty).to.be.false;
+
+        first.resolve();
+
+        expect(second.started).to.eq(1);
+        expect(queue.isEmpty).to.be.true;
+    });
+
+    it('must clear queued entries and reset running state', function () {
+        const queue = new XhrQueueController();
+        const first = new ControlledRunnable();
+        const second = new ControlledRunnable();
+
+        queue.enqueue(first);
+        queue.enqueue(second);
+        queue.clear();
+
+        expect(queue.isEmpty).to.be.true;
+        expect(queue.taskRunning).to.be.false;
+        expect(second.started).to.eq(0);
+    });
+
+    it('must clear queued entries when a runnable rejects', function () {
+        const queue = new XhrQueueController();
+        const first = new ControlledRunnable();
+        const second = new ControlledRunnable();
+
+        queue.enqueue(first);
+        queue.enqueue(second);
+
+        first.reject();
+
+        expect(queue.isEmpty).to.be.true;
+        expect(queue.taskRunning).to.be.false;
+        expect(second.started).to.eq(0);
+    });
+
+    it('must reset running state when next is called on an empty queue', function () {
+        const queue = new XhrQueueController();
+        const first = new ControlledRunnable();
+
+        queue.enqueue(first);
+        first.resolve();
+
+        expect(queue.isEmpty).to.be.true;
+        expect(queue.taskRunning).to.be.false;
+        expect(() => queue.next()).not.to.throw();
+        expect(queue.taskRunning).to.be.false;
+    });
+
+    it('must debounce delayed enqueues by queue key', function () {
+        const clock = sinon.useFakeTimers();
+        const queue = new XhrQueueController();
+        const first = new ControlledRunnable();
+        const second = new ControlledRunnable();
+
+        try {
+            queue.enqueue(first, 50);
+            queue.enqueue(second, 50);
+
+            clock.tick(49);
+            expect(first.started).to.eq(0);
+            expect(second.started).to.eq(0);
+
+            clock.tick(1);
+            expect(first.started).to.eq(0);
+            expect(second.started).to.eq(1);
+        } finally {
+            clock.restore();
+        }
+    });
+
+    it('must debounce two instances independently without cross-interference', function () {
+        const clock = sinon.useFakeTimers();
+        const queueA = new XhrQueueController();
+        const queueB = new XhrQueueController();
+        const runnableA = new ControlledRunnable();
+        const runnableB = new ControlledRunnable();
+
+        try {
+            queueA.enqueue(runnableA, 50);
+            queueB.enqueue(runnableB, 50);
+
+            clock.tick(49);
+            expect(runnableA.started).to.eq(0);
+            expect(runnableB.started).to.eq(0);
+
+            clock.tick(1);
+            expect(runnableA.started).to.eq(1, "queueA runnable must start after its own debounce window");
+            expect(runnableB.started).to.eq(1, "queueB runnable must start after its own debounce window");
+        } finally {
+            clock.restore();
+        }
+    });
+});
+
+class SimpleRunnable extends AsyncRunnable<boolean> {
+    private _shouldResolve: boolean;
+    constructor(resolve = true) { super(); this._shouldResolve = resolve; }
+    cancel() {}
+    start() {
+        if (this._shouldResolve) this.resolve(true);
+        else this.reject(new Error("rejected"));
+    }
+}
+
+describe('AsyncRunnable.finally() tests', () => {
+    it('finally callback must be called on resolve', function () {
+        const r = new SimpleRunnable(true);
+        let finallyCalled = false;
+        r.finally(() => { finallyCalled = true; });
+        r.start();
+        expect(finallyCalled).to.be.true;
+    });
+
+    it('finally callback must be called on reject', function () {
+        const r = new SimpleRunnable(false);
+        let finallyCalled = false;
+        r.catch(() => {}).finally(() => { finallyCalled = true; });
+        r.start();
+        expect(finallyCalled).to.be.true;
+    });
+
+    it('finally callback must be called in addition to then', function () {
+        const r = new SimpleRunnable(true);
+        let thenCalled = false;
+        let finallyCalled = false;
+        r.then(() => { thenCalled = true; }).finally(() => { finallyCalled = true; });
+        r.start();
+        expect(thenCalled).to.be.true;
+        expect(finallyCalled).to.be.true;
+    });
+
+    it('finally callback must be called in addition to catch', function () {
+        const r = new SimpleRunnable(false);
+        let catchCalled = false;
+        let finallyCalled = false;
+        r.catch(() => { catchCalled = true; }).finally(() => { finallyCalled = true; });
+        r.start();
+        expect(catchCalled).to.be.true;
+        expect(finallyCalled).to.be.true;
+    });
+});

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

@@ -1,3 +1,19 @@
+/*! 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";

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

@@ -27,6 +27,12 @@ import {DQ} from "mona-dish";
 import {ErrorData} from "../../impl/xhrCore/ErrorData";
 import * as nise from "nise";
 
+function suppressErrorOutput(): () => void {
+    const oldErr = console.error;
+    console.error = () => {};
+    return () => { console.error = oldErr; };
+}
+
 /**
  * Tests for error recover if an error is triggered mid chain
  */
@@ -68,6 +74,10 @@ describe('Tests of the various aspects of the response protocol functionality',
         });
     });
 
+    let restoreConsoleError: () => void;
+    beforeEach(function () { restoreConsoleError = suppressErrorOutput(); });
+    afterEach(function () { restoreConsoleError?.(); });
+
     afterEach(function () {
         this.closeIt();
     });
@@ -138,11 +148,15 @@ describe('Tests of the various aspects of the response protocol functionality',
     it('must have correct source element within the error Data Object', () => {
         const errorData = new ErrorData("form1:button1", "errorName", "errorMessage");
         expect((errorData.source as Element).id).to.eq("form1:button1");
+        expect(errorData.errorName).to.eq("errorName");
+        expect(errorData.errorMessage).to.eq("errorMessage");
     })
 
     it('should have correct source id string within the error Data Object if element not existing', () => {
         const errorData = new ErrorData("form1:button1:booga", "errorName", "errorMessage");
         expect(errorData.source).to.eq("form1:button1:booga");
+        expect(errorData.errorName).to.eq("errorName");
+        expect(errorData.errorMessage).to.eq("errorMessage");
     })
 });
 

package/src/main/typescript/test/xhrCore/FakeWebsocket.ts

@@ -18,22 +18,38 @@ export class FakeWebsocket {
     onopen: Function = () => {}
     onmessage: Function = () => {}
     onclose: Function = () => {}
+    onerror: Function = () => {}
+    readyState = 0; // 0=CONNECTING, 1=OPEN, 3=CLOSED
 
     constructor() {
         setTimeout(() => {
+            if (this.readyState !== 0) return;
+            this.readyState = 1;
             this.onopen();
         }, 10);
     }
 
+    send() {}
 
-    send() {
-    }
-
+    /** Simulate a message arriving from the server. */
     _respond(response: any) {
         this.onmessage(response);
     }
 
+    /** Simulate a WebSocket error event. */
+    _error(event: any) {
+        this.onerror(event);
+    }
+
+    /** Simulate a server-initiated close with a specific CloseEvent. */
+    _close(event: any = {}) {
+        this.readyState = 3;
+        this.onclose(event);
+    }
+
+    /** Socket-initiated close (called by Socket.close()). */
     close() {
-        this.onclose();
+        this.readyState = 3;
+        this.onclose({});
     }
-}
+}