@neurodevs/node-lsl 18.1.0 → 20.0.0

package/src/__tests__/AbstractPackageTest.ts

@@ -1,3 +1,6 @@
+import { randomInt } from 'node:crypto'
+
+import WebSocket, { Server } from 'ws'
 import {
     FakeLiblsl,
     FakeLibndx,
@@ -6,25 +9,23 @@ import {
     LibndxAdapter,
 } from '@neurodevs/ndx-native'
 import AbstractModuleTest from '@neurodevs/node-tdd'
-import WebSocket, { Server } from 'ws'
 
-import SpyEventMarkerEmitter from '../testDoubles/EventMarkerEmitter/SpyEventMarkerEmitter.js'
-import FakeStreamInfo from '../testDoubles/StreamInfo/FakeStreamInfo.js'
-import SpyStreamInfo from '../testDoubles/StreamInfo/SpyStreamInfo.js'
-import FakeStreamInlet from '../testDoubles/StreamInlet/FakeStreamInlet.js'
-import { SpyStreamInlet } from '../testDoubles/StreamInlet/SpyStreamInlet.js'
-import FakeStreamOutlet from '../testDoubles/StreamOutlet/FakeStreamOutlet.js'
-import SpyLslWebSocketBridge from '../testDoubles/WebSocketBridge/SpyLslWebSocketBridge.js'
+import SpyLslEmitter from '../testDoubles/LslEmitter/SpyLslEmitter.js'
+import FakeLslInfo from '../testDoubles/LslInfo/FakeLslInfo.js'
+import SpyLslInfo from '../testDoubles/LslInfo/SpyLslInfo.js'
+import FakeLslInlet from '../testDoubles/LslInlet/FakeLslInlet.js'
+import SpyLslInlet from '../testDoubles/LslInlet/SpyLslInlet.js'
+import FakeLslOutlet from '../testDoubles/LslOutlet/FakeLslOutlet.js'
+import SpyLslWsBridge from '../testDoubles/LslWsBridge/SpyLslWsBridge.js'
 import FakeWebSocket from '../testDoubles/WebSockets/FakeWebSocket.js'
 import FakeWebSocketServer from '../testDoubles/WebSockets/FakeWebSocketServer.js'
-
 import LslWebSocketBridge from '../impl/LslWebSocketBridge.js'
 import BleDeviceController from '../impl/controllers/BleDeviceController.js'
 import LslEventMarkerEmitter from '../impl/LslEventMarkerEmitter.js'
 import LslStreamInfo from '../impl/LslStreamInfo.js'
 import LslStreamInlet, {
     OnDataCallback,
-    StreamInletOptions,
+    LslInletOptions,
 } from '../impl/LslStreamInlet.js'
 import LslStreamOutlet from '../impl/LslStreamOutlet.js'
 
@@ -32,8 +33,31 @@ export default class AbstractPackageTest extends AbstractModuleTest {
     protected static fakeLiblsl: FakeLiblsl
     protected static fakeLibndx: FakeLibndx
 
+    protected static readonly fakeLslInfo = new FakeLslInfo()
+
+    protected static readonly name_ = this.generateId()
+    protected static readonly type = this.generateId()
+    protected static readonly sourceId = this.generateId()
+    protected static readonly units = this.generateId()
+
+    protected static readonly channelNames = [
+        this.generateId(),
+        this.generateId(),
+        this.generateId(),
+    ]
+
+    protected static readonly channelCount = this.channelNames.length
+
+    protected static readonly chunkSize = randomInt(2, 100)
+    protected static readonly sampleRateHz = Math.floor(Math.random() * 100)
+    protected static readonly maxBufferedMs = Math.floor(Math.random() * 1000)
+
     protected static async beforeEach() {
         await super.beforeEach()
+
+        this.setImmediateTimeouts()
+
+        this.setFakeLibndx()
     }
 
     protected static setFakeLiblsl() {
@@ -44,6 +68,30 @@ export default class AbstractPackageTest extends AbstractModuleTest {
         FakeLiblsl.fakeInfoHandles = [{} as InfoHandle]
     }
 
+    protected static callsToSetTimeout: number[] = []
+
+    protected static setImmediateTimeouts() {
+        this.callsToSetTimeout = []
+
+        BleDeviceController.setTimeout = ((
+            callback: (...args: unknown[]) => void,
+            delayMs?: number,
+            ...args: unknown[]
+        ) => {
+            this.callsToSetTimeout.push(delayMs ?? 0)
+            return setTimeout(callback, 0, ...args)
+        }) as unknown as typeof setTimeout
+
+        LslStreamOutlet.setTimeout = ((
+            callback: (...args: unknown[]) => void,
+            delayMs?: number,
+            ...args: unknown[]
+        ) => {
+            this.callsToSetTimeout.push(delayMs ?? 0)
+            return setTimeout(callback, 0, ...args)
+        }) as unknown as typeof setTimeout
+    }
+
     protected static setFakeLibndx() {
         this.fakeLibndx = new FakeLibndx()
         LibndxAdapter.setInstance(this.fakeLibndx)
@@ -54,36 +102,36 @@ export default class AbstractPackageTest extends AbstractModuleTest {
         BleDeviceController.ndx = this.fakeLibndx
     }
 
-    protected static setSpyStreamInfo() {
-        LslStreamInfo.Class = SpyStreamInfo
-        SpyStreamInfo.resetTestDouble()
+    protected static setSpyLslInfo() {
+        LslStreamInfo.Class = SpyLslInfo
+        SpyLslInfo.resetTestDouble()
     }
 
-    protected static setFakeStreamInfo() {
-        LslStreamInfo.Class = FakeStreamInfo
-        FakeStreamInfo.resetTestDouble()
+    protected static setFakeLslInfo() {
+        LslStreamInfo.Class = FakeLslInfo
+        FakeLslInfo.resetTestDouble()
     }
 
-    protected static setSpyStreamInlet() {
-        LslStreamInlet.Class = SpyStreamInlet
+    protected static setSpyLslInlet() {
+        LslStreamInlet.Class = SpyLslInlet
     }
 
-    protected static setFakeStreamInlet() {
-        LslStreamInlet.Class = FakeStreamInlet
-        FakeStreamInlet.resetTestDouble()
+    protected static setFakeLslInlet() {
+        LslStreamInlet.Class = FakeLslInlet
+        FakeLslInlet.resetTestDouble()
     }
 
-    protected static setFakeStreamOutlet() {
-        LslStreamOutlet.Class = FakeStreamOutlet
-        FakeStreamOutlet.resetTestDouble()
+    protected static setFakeLslOutlet() {
+        LslStreamOutlet.Class = FakeLslOutlet
+        FakeLslOutlet.resetTestDouble()
     }
 
-    protected static setSpyEventMarkerEmitter() {
-        LslEventMarkerEmitter.Class = SpyEventMarkerEmitter
+    protected static setSpyLslEmitter() {
+        LslEventMarkerEmitter.Class = SpyLslEmitter
     }
 
-    protected static setSpyLslWebSocketBridge() {
-        LslWebSocketBridge.Class = SpyLslWebSocketBridge
+    protected static setSpyLslWsBridge() {
+        LslWebSocketBridge.Class = SpyLslWsBridge
     }
 
     protected static setFakeWebSocket() {
@@ -96,30 +144,11 @@ export default class AbstractPackageTest extends AbstractModuleTest {
         FakeWebSocketServer.resetTestDouble()
     }
 
-    protected static readonly fakeStreamInfo = new FakeStreamInfo()
-
-    protected static readonly name_ = this.generateId()
-    protected static readonly type = this.generateId()
-    protected static readonly sourceId = this.generateId()
-    protected static readonly units = this.generateId()
-
-    protected static readonly channelNames = [
-        this.generateId(),
-        this.generateId(),
-        this.generateId(),
-    ]
-
-    protected static readonly channelCount = this.channelNames.length
-
-    protected static readonly chunkSize = 2
-    protected static readonly sampleRateHz = Math.floor(Math.random() * 100)
-    protected static readonly maxBufferedMs = Math.floor(Math.random() * 1000)
-
     protected static async LslStreamInlet(
-        options: Partial<StreamInletOptions>,
+        options: Partial<LslInletOptions>,
         onData: OnDataCallback
     ) {
-        const defaultOptions: StreamInletOptions = {
+        const defaultOptions: LslInletOptions = {
             sourceId: this.sourceId,
             chunkSize: this.chunkSize,
             maxBufferedMs: this.maxBufferedMs,

package/src/__tests__/impl/BleDeviceController.test.ts

@@ -35,6 +35,14 @@ export default class BleDeviceControllerTest extends AbstractPackageTest {
         },
     ]
 
+    private static readonly extraCharCallbacks = [
+        {
+            charUuid: this.generateId(),
+            charName: this.generateId(),
+            onData: async () => {},
+        },
+    ]
+
     private static onConnected = (_peripheral: NativePeripheral) => {
         this.wasConnected = true
     }
@@ -58,13 +66,11 @@ export default class BleDeviceControllerTest extends AbstractPackageTest {
         await super.beforeEach()
 
         BleDeviceController.waitAfterMs = 0
-
-        this.setFakeLibndx()
         BleDeviceController.Class = SpyBleController
 
         this.wasConnected = false
 
-        this.instance = await this.BleController()
+        this.instance = this.BleDeviceController()
     }
 
     @test()
@@ -262,13 +268,10 @@ export default class BleDeviceControllerTest extends AbstractPackageTest {
         const waitAfterMs = 20
         BleDeviceController.waitAfterMs = waitAfterMs
 
-        const t0 = Date.now()
         await this.connect()
-        const t1 = Date.now()
 
-        assert.isAbove(
-            t1 - t0,
-            100 + waitAfterMs * 0.8,
+        assert.isTruthy(
+            this.callsToSetTimeout.includes(waitAfterMs),
             'Did not wait after on connected!'
         )
     }
@@ -310,6 +313,42 @@ export default class BleDeviceControllerTest extends AbstractPackageTest {
         )
     }
 
+    @test()
+    protected static async subscribeCharacteristicsCallsLibndxBinding() {
+        await this.subscribeCharacteristics()
+
+        assert.isEqualDeep(
+            FakeLibndx.callsToAddBleCharCallbacks[0],
+            {
+                deviceUuid: this.uuid,
+                charCallbacks: this.extraCharCallbacks,
+            },
+            'Did not call addBleCharCallbacks as expected!'
+        )
+    }
+
+    @test()
+    protected static async subscribeCharacteristicsMergesIntoCharCallbacks() {
+        await this.subscribeCharacteristics()
+
+        assert.isEqualDeep(
+            this.instance.getCharacteristicCallbacks(),
+            [...this.charCallbacks, ...this.extraCharCallbacks],
+            'Did not merge the newly subscribed callbacks into charCallbacks!'
+        )
+    }
+
+    @test()
+    protected static async subscribeCharacteristicsThrowsOn400() {
+        this.setFake400Error()
+
+        await assert.doesThrowAsync(
+            async () => await this.subscribeCharacteristics(),
+            this.fake400Error,
+            'Did not throw error!'
+        )
+    }
+
     @test()
     protected static async callsSetBleRssiInterval() {
         await this.connect()
@@ -431,7 +470,7 @@ export default class BleDeviceControllerTest extends AbstractPackageTest {
                 if (getCall()) {
                     resolve()
                 } else {
-                    setTimeout(check, 10)
+                    setTimeout(check, 0)
                 }
             }
             check()
@@ -445,6 +484,10 @@ export default class BleDeviceControllerTest extends AbstractPackageTest {
         )
     }
 
+    private static async subscribeCharacteristics() {
+        await this.instance.subscribeCharacteristics(this.extraCharCallbacks)
+    }
+
     private static async disconnect() {
         await this.instance.disconnect()
     }
@@ -469,24 +512,22 @@ export default class BleDeviceControllerTest extends AbstractPackageTest {
         }
     }
 
-    private static async BleController(
+    private static BleDeviceController(
         options?: Partial<BleControllerOptions>
     ) {
-        return (await BleDeviceController.Create({
+        return BleDeviceController.Create({
             deviceUuid: this.uuid,
             charCallbacks: this.charCallbacks,
             onConnected: this.onConnected,
             rssiIntervalMs: this.rssiIntervalMs,
             ...options,
-        })) as SpyBleController
+        }) as SpyBleController
     }
 
-    private static async BleControllerWithPrefix() {
-        return (await BleDeviceController.Create({
+    private static BleControllerWithPrefix() {
+        return this.BleDeviceController({
             deviceNamePrefix: this.namePrefix,
-            charCallbacks: this.charCallbacks,
-            onConnected: this.onConnected,
-            rssiIntervalMs: this.rssiIntervalMs,
-        } as unknown as BleControllerOptions)) as SpyBleController
+            deviceUuid: undefined,
+        })
     }
 }

package/src/__tests__/impl/LslEventMarkerEmitter.test.ts

@@ -3,23 +3,23 @@ import { randomInt } from 'node:crypto'
 import { assert, test } from '@neurodevs/node-tdd'
 
 import LslEventMarkerEmitter, {
-    EventMarkerOptions,
+    EmitOptions,
 } from '../../impl/LslEventMarkerEmitter.js'
-import { StreamOutletOptions } from '../../impl/LslStreamOutlet.js'
-import SpyEventMarkerEmitter from '../../testDoubles/EventMarkerEmitter/SpyEventMarkerEmitter.js'
+import { LslOutletOptions } from '../../impl/LslStreamOutlet.js'
+import SpyLslEmitter from '../../testDoubles/LslEmitter/SpyLslEmitter.js'
 import generateRandomOutletOptions from '../../testDoubles/generateRandomOutletOptions.js'
-import FakeStreamOutlet from '../../testDoubles/StreamOutlet/FakeStreamOutlet.js'
+import FakeLslOutlet from '../../testDoubles/LslOutlet/FakeLslOutlet.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 
 export default class EventMarkerEmitterTest extends AbstractPackageTest {
-    private static instance: SpyEventMarkerEmitter
+    private static instance: SpyLslEmitter
 
     protected static async beforeEach() {
         await super.beforeEach()
 
         this.setFakeLiblsl()
-        this.setFakeStreamOutlet()
-        this.setSpyEventMarkerEmitter()
+        this.setFakeLslOutlet()
+        this.setSpyLslEmitter()
 
         this.instance = await this.LslEventMarkerEmitter()
     }
@@ -35,7 +35,7 @@ export default class EventMarkerEmitterTest extends AbstractPackageTest {
     protected static async loadsWithEventMarkerSpecificOptions() {
         assert.isEqualDeep(
             {
-                ...FakeStreamOutlet.callsToConstructor[0],
+                ...FakeLslOutlet.callsToConstructor[0],
                 name: undefined,
                 sourceId: undefined,
             },
@@ -51,14 +51,14 @@ export default class EventMarkerEmitterTest extends AbstractPackageTest {
         )
 
         assert.isTrue(
-            FakeStreamOutlet.callsToConstructor[0]?.sourceId.startsWith(
+            FakeLslOutlet.callsToConstructor[0]?.sourceId.startsWith(
                 'event-markers-'
             ),
             'Source ID was not generated uniquely!'
         )
 
         assert.isTrue(
-            FakeStreamOutlet.callsToConstructor[0]?.name.startsWith(
+            FakeLslOutlet.callsToConstructor[0]?.name.startsWith(
                 'Event markers ('
             ),
             'Name was not generated uniquely!'
@@ -70,7 +70,7 @@ export default class EventMarkerEmitterTest extends AbstractPackageTest {
         const options = generateRandomOutletOptions()
         await this.LslEventMarkerEmitter(options)
 
-        assert.isEqualDeep(FakeStreamOutlet.callsToConstructor[1], options)
+        assert.isEqualDeep(FakeLslOutlet.callsToConstructor[1], options)
     }
 
     @test()
@@ -81,7 +81,7 @@ export default class EventMarkerEmitterTest extends AbstractPackageTest {
         const marker = markers[0]
 
         assert.isEqual(
-            FakeStreamOutlet.callsToPushSample[0]?.sample[0],
+            FakeLslOutlet.callsToPushSample[0]?.sample[0],
             marker.name,
             'Pushed the wrong marker!'
         )
@@ -93,7 +93,7 @@ export default class EventMarkerEmitterTest extends AbstractPackageTest {
     protected static async emittingTwoMarkersIncrementsHitCountAndWaitTimeTwice() {
         const markers = await this.emitManyFor(2)
 
-        assert.isEqual(FakeStreamOutlet.callsToPushSample.length, 2)
+        assert.isEqual(FakeLslOutlet.callsToPushSample.length, 2)
 
         assert.isEqual(
             this.instance.totalwaitAfterMs,
@@ -162,7 +162,7 @@ export default class EventMarkerEmitterTest extends AbstractPackageTest {
         await this.emit(markerName)
 
         assert.isEqualDeep(
-            FakeStreamOutlet.callsToPushSample[0]?.sample,
+            FakeLslOutlet.callsToPushSample[0]?.sample,
             [markerName],
             'Pushed the wrong sample!'
         )
@@ -170,7 +170,7 @@ export default class EventMarkerEmitterTest extends AbstractPackageTest {
 
     @test()
     protected static async emitWaitsForMsIfPassed() {
-        SpyEventMarkerEmitter.shouldCallWaitOnSuper = true
+        SpyLslEmitter.shouldCallWaitOnSuper = true
 
         const waitAfterMs = 10
 
@@ -190,7 +190,7 @@ export default class EventMarkerEmitterTest extends AbstractPackageTest {
         this.destroy()
 
         assert.isEqual(
-            FakeStreamOutlet.numCallsToDestroy,
+            FakeLslOutlet.numCallsToDestroy,
             1,
             'Did not call destroy on outlet!'
         )
@@ -268,10 +268,7 @@ export default class EventMarkerEmitterTest extends AbstractPackageTest {
         await this.emit(this.markerName)
     }
 
-    private static async emit(
-        markerName: string,
-        options?: EventMarkerOptions
-    ) {
+    private static async emit(markerName: string, options?: EmitOptions) {
         return this.instance.emit(markerName, options)
     }
 
@@ -314,10 +311,8 @@ export default class EventMarkerEmitterTest extends AbstractPackageTest {
     }
 
     private static async LslEventMarkerEmitter(
-        options?: Partial<StreamOutletOptions>
+        options?: Partial<LslOutletOptions>
     ) {
-        return (await LslEventMarkerEmitter.Create(
-            options
-        )) as SpyEventMarkerEmitter
+        return (await LslEventMarkerEmitter.Create(options)) as SpyLslEmitter
     }
 }

package/src/__tests__/impl/LslStreamInfo.test.ts

@@ -1,18 +1,18 @@
 import { test, assert } from '@neurodevs/node-tdd'
 
-import { CHANNEL_FORMATS } from '../../consts.js'
-import LslStreamInfo, { StreamInfoOptions } from '../../impl/LslStreamInfo.js'
-import SpyStreamInfo from '../../testDoubles/StreamInfo/SpyStreamInfo.js'
+import LslStreamInfo, { LslInfoOptions } from '../../impl/LslStreamInfo.js'
+import SpyLslInfo from '../../testDoubles/LslInfo/SpyLslInfo.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
+import { CHANNEL_FORMATS } from '@neurodevs/ndx-native'
 
 export default class LslStreamInfoTest extends AbstractPackageTest {
-    private static instance: SpyStreamInfo
+    private static instance: SpyLslInfo
 
     protected static async beforeEach() {
         await super.beforeEach()
 
         this.setFakeLiblsl()
-        this.setSpyStreamInfo()
+        this.setSpyLslInfo()
 
         this.instance = this.LslStreamInfo()
     }
@@ -225,12 +225,12 @@ export default class LslStreamInfoTest extends AbstractPackageTest {
         channelNames: this.channelNames,
         channelFormat: 'float32',
         sampleRateHz: 100 * Math.random(),
-    } as StreamInfoOptions
+    } as LslInfoOptions
 
-    private static LslStreamInfo(options?: Partial<StreamInfoOptions>) {
+    private static LslStreamInfo(options?: Partial<LslInfoOptions>) {
         return LslStreamInfo.Create({
             ...this.defaultOptions,
             ...options,
-        }) as SpyStreamInfo
+        }) as SpyLslInfo
     }
 }