Add tests for the wakelock feature.

DO NOT MERGE (this is still a Work in Progress).

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,77 @@
+/* jshint expr: true */
+
+import WakeLockManager from '../core/util/wakelock.js';
+
+class FakeWakeLockSentinal extends EventTarget {
+    constructor() {
+        super();
+        this.released = false;
+        let {promise: releaseBlocked, resolve} = Promise.withResolvers();
+        this.releaseBlocked = releaseBlocked;
+        this._resolveReleaseBlocked = resolve;
+        this.blockReleasePromise = null;
+    }
+
+    async release() {
+        if (this.released) {
+            return;
+        }
+
+        this._resolveReleaseBlocked();
+        if (this.blockReleasePromise !== null) {
+            await this.blockReleasePromise;
+            this.blockReleasePromise = null;
+        }
+        this.released = true;
+        this.dispatchEvent(new Event("release"));
+    }
+}
+
+function waitForStateTransition(wakelockManager, new_state) {
+    const {promise, resolve} = Promise.withResolvers();
+
+    const eventListener = (event) => {
+        console.warn(`Got state change: ${event.old_state} -> ${event.new_state}`);
+        if (event.new_state !== new_state) {
+            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('does a thing', 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;
+    });
+
+});