Add tests for the wakelock feature.

Add tests to for both the `rfb` side (calling into the new wakelock
code), and the new wakelock class (which tracks the desired state and
how to get there).

Author: Greg Darke

tests/test.rfb.js

@@ -9,6 +9,7 @@ import KeyTable from '../core/input/keysym.js';
 import legacyCrypto from '../core/crypto/crypto.js';
 
 import FakeWebSocket from './fake.websocket.js';
+import WakeLockManager from '../core/util/wakelock.js';
 
 function push8(arr, num) {
     "use strict";
@@ -5148,6 +5149,102 @@ describe('Remote Frame Buffer protocol client', function () {
             expect(RFB.messages.clientEncodings.getCall(0).args[1]).to.include(encodings.pseudoEncodingCompressLevel0 + newCompression);
         });
     });
+
+    describe('wakelock setting', function () {
+        let client;
+
+        beforeEach(function () {
+            sinon.spy(WakeLockManager.prototype, "acquire");
+            sinon.spy(WakeLockManager.prototype, "release");
+
+            client = makeRFB();
+        });
+
+        afterEach(function () {
+            WakeLockManager.prototype.acquire.restore();
+            WakeLockManager.prototype.release.restore();
+        });
+
+        it('should acquire wakelock when connected', function() {
+            expect(WakeLockManager.prototype.acquire).to.not.have.been.called;
+
+            client.requestLocalWakelock = true;
+            expect(WakeLockManager.prototype.acquire).to.have.been.calledOnce;
+        });
+
+        it('should acquire wakelock after connection', function() {
+            expect(WakeLockManager.prototype.acquire).to.not.have.been.called;
+            client._rfbConnectionState = 'connecting';
+
+            client.requestLocalWakelock = true;
+            expect(WakeLockManager.prototype.acquire).to.not.have.been.called;
+
+            client._updateConnectionState('connected');
+            expect(WakeLockManager.prototype.acquire).to.have.been.calledOnce;
+        });
+
+        it('should release wakelock when disabled', function() {
+            client.requestLocalWakelock = true;
+            expect(WakeLockManager.prototype.acquire).to.have.been.calledOnce;
+            expect(WakeLockManager.prototype.release).to.not.have.been.called;
+
+            client.requestLocalWakelock = false;
+            expect(WakeLockManager.prototype.release).to.have.been.calledOnce;
+        });
+
+        it('should release wakelock when disconnected', function() {
+            client.requestLocalWakelock = true;
+            expect(WakeLockManager.prototype.acquire).to.have.been.calledOnce;
+            expect(WakeLockManager.prototype.release).to.not.have.been.called;
+
+            client.disconnect();
+            expect(WakeLockManager.prototype.release).to.have.been.calledOnce;
+        });
+
+        it('should behave sensibly with non-boolean values', function() {
+            // Client starts with requestLocakWakelock = false, setting it to
+            // the same value should have no effect.
+            client.requestLocalWakelock = false;
+            expect(client.requestLocalWakelock).to.be.false;
+            expect(WakeLockManager.prototype.acquire).to.not.have.been.called;
+            expect(WakeLockManager.prototype.release).to.not.have.been.called;
+
+            // Setting it to something else falsely should have no effect.
+            client.requestLocalWakelock = null;
+            expect(client.requestLocalWakelock).to.be.false;
+            expect(WakeLockManager.prototype.acquire).to.not.have.been.called;
+            expect(WakeLockManager.prototype.release).to.not.have.been.called;
+
+            // Setting it to something else falsely should have no effect.
+            client.requestLocalWakelock = undefined;
+            expect(client.requestLocalWakelock).to.be.false;
+            expect(WakeLockManager.prototype.acquire).to.not.have.been.called;
+            expect(WakeLockManager.prototype.release).to.not.have.been.called;
+
+            // Switching to something true should trigger a single call to
+            // acquire.
+            client.requestLocalWakelock = true;
+            expect(client.requestLocalWakelock).to.be.true;
+            expect(WakeLockManager.prototype.acquire).to.have.been.calledOnce;
+            expect(WakeLockManager.prototype.release).to.not.have.been.called;
+
+            WakeLockManager.prototype.acquire.resetHistory();
+
+            // Switching to something else trueish should have no effect.
+            client.requestLocalWakelock = "some-value";
+            expect(client.requestLocalWakelock).to.be.true;
+            expect(WakeLockManager.prototype.acquire).to.not.have.been.called;
+            expect(WakeLockManager.prototype.release).to.not.have.been.called;
+
+            // Validate that switching from a trueish value to a falseish value
+            // works.
+            client.requestLocalWakelock = null;
+            expect(client.requestLocalWakelock).to.be.false;
+            expect(WakeLockManager.prototype.acquire).to.not.have.been.called;
+            expect(WakeLockManager.prototype.release).to.have.been.calledOnce;
+        });
+
+    });
 });
 
 describe('RFB messages', function () {

tests/test.wakelock.js

@@ -0,0 +1,198 @@
+/* jshint expr: true */
+
+import WakeLockManager from '../core/util/wakelock.js';
+
+class FakeWakeLockSentinal extends EventTarget {
+    constructor() {
+        super();
+        this.released = false;
+    }
+
+    async release() {
+        if (this.released) {
+            return;
+        }
+        this.released = true;
+        this.dispatchEvent(new Event("release"));
+    }
+}
+
+function waitForStateTransition(wakelockManager, newState) {
+    const {promise, resolve} = Promise.withResolvers();
+
+    const eventListener = (event) => {
+        console.warn(`Got state change: ${event.oldState} -> ${event.newState}`);
+        if (event.newState !== newState) {
+            return;
+        }
+        wakelockManager.removeEventListener("testOnlyStateChange", eventListener);
+        resolve();
+    };
+    wakelockManager.addEventListener("testOnlyStateChange", eventListener);
+
+    return promise;
+}
+
+describe('WakeLockManager', function () {
+    "use strict";
+
+    let wakelockRequest;
+    beforeEach(function() {
+        wakelockRequest = sinon.stub(navigator.wakeLock, 'request');
+    })
+    afterEach(function() {
+        wakelockRequest.restore();
+    });
+    
+    it('can acquire and release lock', async function() {
+        let wakeLockSentinal = new FakeWakeLockSentinal();
+        wakelockRequest.onFirstCall().resolves(wakeLockSentinal);
+
+        let wlm = new WakeLockManager();
+        expect(wakelockRequest).to.not.have.been.called;
+
+        let done = waitForStateTransition(wlm, 'acquired');
+        wlm.acquire();
+        await done;
+        expect(wakelockRequest).to.have.been.calledOnce;
+        expect(wakeLockSentinal.released).to.be.false;
+
+        done = waitForStateTransition(wlm, 'released');
+        wlm.release();
+        await done;
+        expect(wakelockRequest).to.have.been.calledOnce;
+        expect(wakeLockSentinal.released).to.be.true;
+    });
+
+    it('can release without holding wakelock', async function() {
+        let wlm = new WakeLockManager();
+        wlm.release();
+        expect(wakelockRequest).to.not.have.been.called;
+    });
+
+    it('can release while waiting for wakelock', async function() {
+        let wakeLockSentinal = new FakeWakeLockSentinal();
+        let {promise, resolve} = Promise.withResolvers();
+
+        wakelockRequest.onFirstCall().returns(promise);
+
+        let wlm = new WakeLockManager();
+        expect(wakelockRequest).to.not.have.been.called;
+
+        let seenAcquiring = waitForStateTransition(wlm, 'acquiring');
+        let seenReleasing = waitForStateTransition(wlm, 'releasing');
+        let seenReleased = waitForStateTransition(wlm, 'released');
+
+        wlm.acquire();
+        await seenAcquiring;
+        expect(wakelockRequest).to.have.been.calledOnce;
+
+        // We can call acquire multiple times, while waiting for the promise
+        // to resolve.
+        wlm.acquire();
+        // It should not request a second wakelock.
+        expect(wakelockRequest).to.have.been.calledOnce;
+
+        wlm.release();
+        await seenReleasing;
+
+        expect(wakeLockSentinal.released).to.be.false;
+
+        // Now return the wake lock, we should immediately release it.
+        resolve(wakeLockSentinal);
+        await seenReleased;
+        expect(wakeLockSentinal.released).to.be.true;
+    });
+
+    it('handles visibility loss', async function() {
+        let documentHidden = sinon.stub(document, 'hidden');
+        let documentVisibility = sinon.stub(document, 'visibilityState');
+        afterEach(function() {
+            documentHidden.restore();
+            documentVisibility.restore();
+        });
+        documentHidden.value(false);
+        documentVisibility.value('visible');
+
+        let wakeLockSentinal1 = new FakeWakeLockSentinal();
+        let wakeLockSentinal2 = new FakeWakeLockSentinal();
+        wakelockRequest.onFirstCall().resolves(wakeLockSentinal1);
+        wakelockRequest.onSecondCall().resolves(wakeLockSentinal2);
+
+        let wlm = new WakeLockManager();
+        let seenAcquired = waitForStateTransition(wlm, 'acquired');
+        let seenAwaitingVisible = waitForStateTransition(wlm, 'awaiting_visible');
+
+        wlm.acquire();
+        await seenAcquired;
+        expect(wakelockRequest).to.have.been.calledOnce;
+
+        // Fake a visibility change.
+        documentHidden.value(true);
+        documentVisibility.value('hidden');
+        wakeLockSentinal1.release()
+
+        await seenAwaitingVisible;
+        seenAcquired = waitForStateTransition(wlm, 'acquired');
+
+        // Fake a visibility change back
+        documentHidden.value(false);
+        documentVisibility.value('visible');
+        document.dispatchEvent(new Event('visibilitychange'));
+        await seenAcquired;
+
+        expect(wakelockRequest).to.have.been.calledTwice;
+        expect(wakeLockSentinal2.released).to.be.false;
+    });
+
+    it('can start hidden', async function() {
+        let documentHidden = sinon.stub(document, 'hidden');
+        let documentVisibility = sinon.stub(document, 'visibilityState');
+        afterEach(function() {
+            documentHidden.restore();
+            documentVisibility.restore();
+        });
+        documentHidden.value(true);
+        documentVisibility.value('hidden');
+
+        let wakeLockSentinal = new FakeWakeLockSentinal();
+        wakelockRequest.onFirstCall().resolves(wakeLockSentinal);
+
+        let wlm = new WakeLockManager();
+        let seenAwaitingVisible = waitForStateTransition(wlm, 'awaiting_visible');
+        let seenAcquired = waitForStateTransition(wlm, 'acquired');
+
+        wlm.acquire();
+        await seenAwaitingVisible;
+        expect(wakelockRequest).to.not.have.been.called;
+
+        // Fake a visibility change.
+        documentHidden.value(false);
+        documentVisibility.value('visible');
+        document.dispatchEvent(new Event('visibilitychange'));
+        await seenAcquired;
+
+        expect(wakelockRequest).to.have.been.calledOnce;
+        expect(wakeLockSentinal.released).to.be.false;
+    });
+
+    it('handles acquire errors', async function() {
+        wakelockRequest.onFirstCall().rejects('WakeLockError');
+        let wakeLockSentinal = new FakeWakeLockSentinal();
+        wakelockRequest.onSecondCall().resolves(wakeLockSentinal);
+
+        let wlm = new WakeLockManager();
+
+        let seenError = waitForStateTransition(wlm, 'error');
+        wlm.acquire();
+        await seenError;
+        expect(wakelockRequest).to.have.been.calledOnce;
+
+        // Even though we saw an error previously, it will retry when
+        // requested.
+        let seenAcquired = waitForStateTransition(wlm, 'acquired');
+        wlm.acquire();
+        await seenAcquired;
+        expect(wakelockRequest).to.have.been.calledTwice;
+    });
+});