@neurodevs/node-lsl 18.1.0 → 20.0.0

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

@@ -1,5 +1,3 @@
-import { Worker } from 'node:worker_threads'
-
 import { FakeLiblsl } from '@neurodevs/ndx-native'
 import { test, assert } from '@neurodevs/node-tdd'
 import {
@@ -11,16 +9,12 @@ import {
     unwrapPointer,
 } from 'ffi-rs'
 
-import LslStreamInlet, {
-    StreamInletOptions,
-} from '../../impl/LslStreamInlet.js'
-import StreamInletWorker from '../../impl/workers/inlet/StreamInletWorker.js'
-import { SpyStreamInlet } from '../../testDoubles/StreamInlet/SpyStreamInlet.js'
-import FakeWorker from '../../testDoubles/WorkerThreads/FakeWorker.js'
+import LslStreamInlet, { LslInletOptions } from '../../impl/LslStreamInlet.js'
+import SpyLslInlet from '../../testDoubles/LslInlet/SpyLslInlet.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 
 export default class LslStreamInletTest extends AbstractPackageTest {
-    private static instance: SpyStreamInlet
+    private static instance: SpyLslInlet
 
     private static callsToOnData: {
         samples: number[]
@@ -60,20 +54,14 @@ export default class LslStreamInletTest extends AbstractPackageTest {
         await super.beforeEach()
 
         this.setFakeLiblsl()
-        this.setFakeStreamInfo()
-        this.setSpyStreamInlet()
+        this.setFakeLslInfo()
+        this.setSpyLslInlet()
 
         this.callsToOnData = []
 
         LslStreamInlet.waitAfterOpenStreamMs = 0
-
-        LslStreamInlet.Worker = FakeWorker as unknown as typeof Worker
-        FakeWorker.resetTestDoubles()
-
-        StreamInletWorker.lsl = this.fakeLiblsl
-        StreamInletWorker.freePointer = () => {}
-
-        FakeWorker.fakeOnData = this.onData
+        LslStreamInlet.lsl = this.fakeLiblsl
+        LslStreamInlet.freePointer = () => {}
 
         this.instance = await this.LslStreamInlet()
     }
@@ -133,7 +121,7 @@ export default class LslStreamInletTest extends AbstractPackageTest {
 
         let calls: FreePointerParams[] = []
 
-        StreamInletWorker.freePointer = (params: FreePointerParams) => {
+        LslStreamInlet.freePointer = (params: FreePointerParams) => {
             calls.push(params)
         }
 
@@ -201,9 +189,7 @@ export default class LslStreamInletTest extends AbstractPackageTest {
         await this.startPulling()
 
         assert.isEqual(
-            FakeWorker.callsToPostMessage.filter(
-                (msg) => msg.type === 'startPulling'
-            ).length,
+            this.fakeLiblsl.createInletHitCount,
             1,
             'startPulling did not return early!'
         )
@@ -243,7 +229,7 @@ export default class LslStreamInletTest extends AbstractPackageTest {
         assert.isEqualDeep(
             this.fakeLiblsl.lastOpenStreamOptions,
             {
-                inletHandle: this.inletHandle,
+                inletHandle: instance['inletHandle'],
                 timeoutMs: openStreamTimeoutMs,
                 errorCodePtr: this.errorCodePtr,
             },
@@ -253,27 +239,6 @@ export default class LslStreamInletTest extends AbstractPackageTest {
         instance.stopPulling()
     }
 
-    @test()
-    protected static async waitsAfterOpeningStreamWithPassedOption() {
-        const waitAfterOpenStreamMs = 10
-
-        const instance = await this.LslStreamInlet({
-            waitAfterOpenStreamMs,
-        })
-
-        let t0 = Date.now()
-        await this.startPulling(instance)
-        let elapsed = Date.now() - t0
-
-        instance.stopPulling()
-
-        assert.isAbove(
-            elapsed,
-            waitAfterOpenStreamMs * 0.8,
-            'Did not wait after opening stream!'
-        )
-    }
-
     @test()
     protected static async stopPullingClosesInletStream() {
         await this.startPulling()
@@ -386,15 +351,10 @@ export default class LslStreamInletTest extends AbstractPackageTest {
     protected static async pushSampleHandlesErrorCode() {
         let passedErrorCode: number | undefined
 
-        StreamInletWorker.handleLslError = (errorCode: number) => {
+        LslStreamInlet.handleLslError = (errorCode: number) => {
             passedErrorCode = errorCode
         }
 
-        const fakeErrorCode = [-4, -3, -2, -1, 0][Math.floor(Math.random() * 5)]
-        const worker = this.getFakeWorker()
-
-        worker['inletWorker']['pullErrorBuffer'].writeInt32LE(fakeErrorCode)
-
         await this.startThenStop()
 
         assert.isEqualDeep(
@@ -414,10 +374,9 @@ export default class LslStreamInletTest extends AbstractPackageTest {
 
         let pulls = 0
 
-        const inletWorker = this.getFakeWorker(instance)['inletWorker']
-        const original = inletWorker['pullDataOnce'].bind(inletWorker)
+        const original = instance['pullDataOnce'].bind(instance)
 
-        inletWorker['pullDataOnce'] = async () => {
+        instance['pullDataOnce'] = async () => {
             pulls++
             await original()
         }
@@ -508,32 +467,23 @@ export default class LslStreamInletTest extends AbstractPackageTest {
     }
 
     private static async runInletWithOptions(
-        options?: Partial<StreamInletOptions>
+        options?: Partial<LslInletOptions>
     ) {
         const inlet = await this.LslStreamInlet(options)
+        this.instance = inlet
         await this.startThenStop(inlet)
         return inlet
     }
 
-    private static async startThenStop(inlet?: SpyStreamInlet) {
+    private static async startThenStop(inlet?: SpyLslInlet) {
         const instance = inlet || this.instance
         await this.startPulling(instance)
         await this.wait(10)
         instance.stopPulling()
     }
 
-    private static async startPulling(instance?: SpyStreamInlet) {
-        const inst = instance || this.instance
-        const startPullingPromise = inst.startPulling()
-
-        while (!this.getFakeWorker(inst).createInletPromise) {
-            await this.wait(1)
-        }
-
-        await this.getFakeWorker(inst).createInletPromise
-        inst['workerReady'] = true
-
-        await startPullingPromise
+    private static async startPulling(instance?: SpyLslInlet) {
+        await (instance || this.instance).startPulling()
     }
 
     private static stopPulling() {
@@ -549,26 +499,19 @@ export default class LslStreamInletTest extends AbstractPackageTest {
     }
 
     private static get inletHandle() {
-        return this.getFakeWorker()['inletWorker']['inletHandle']
-    }
-
-    private static getFakeWorker(instance?: SpyStreamInlet) {
-        const inst = instance || this.instance
-        return inst['worker'] as unknown as FakeWorker
+        return this.instance['inletHandle']
     }
 
     private static onData = (samples: number[], timestamps: number[]) => {
         this.callsToOnData.push({ samples, timestamps })
     }
 
-    protected static async LslStreamInlet(
-        options?: Partial<StreamInletOptions>
-    ) {
+    protected static async LslStreamInlet(options?: Partial<LslInletOptions>) {
         return (await AbstractPackageTest.LslStreamInlet(
             {
                 ...options,
             },
             this.onData
-        )) as SpyStreamInlet
+        )) as SpyLslInlet
     }
 }

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

@@ -1,27 +1,25 @@
-import { Worker } from 'node:worker_threads'
-import { ChannelFormat, LslSample, FakeLiblsl } from '@neurodevs/ndx-native'
+import {
+    ChannelFormat,
+    LslSample,
+    FakeLiblsl,
+    CHANNEL_FORMATS,
+} from '@neurodevs/ndx-native'
 import { test, assert } from '@neurodevs/node-tdd'
 
-import { CHANNEL_FORMATS } from '../../consts.js'
 import LslStreamOutlet, {
-    StreamOutletOptions,
+    LslOutletOptions,
 } from '../../impl/LslStreamOutlet.js'
-import {
-    setOutletHandleLslError,
-    setOutletLiblslAdapter,
-} from '../../impl/workers/outlet/LslStreamOutlet.worker.js'
 import {
     TEST_SUPPORTED_CHANNEL_FORMATS,
     TEST_UNSUPPORTED_CHANNEL_FORMATS,
     TestChannelFormat,
 } from '../../testDoubles/consts.js'
 import generateRandomOutletOptions from '../../testDoubles/generateRandomOutletOptions.js'
-import FakeStreamInfo from '../../testDoubles/StreamInfo/FakeStreamInfo.js'
-import FakeWorker from '../../testDoubles/WorkerThreads/FakeWorker.js'
+import FakeLslInfo from '../../testDoubles/LslInfo/FakeLslInfo.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 
 export default class LslStreamOutletTest extends AbstractPackageTest {
-    private static randomOutletOptions: StreamOutletOptions
+    private static randomOutletOptions: LslOutletOptions
 
     protected static async beforeEach() {
         await super.beforeEach()
@@ -31,12 +29,9 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
         this.randomOutletOptions = generateRandomOutletOptions()
 
         this.setFakeLiblsl()
-        this.setFakeStreamInfo()
+        this.setFakeLslInfo()
 
-        LslStreamOutlet.Worker = FakeWorker as unknown as typeof Worker
-        FakeWorker.resetTestDoubles()
-
-        setOutletLiblslAdapter(this.fakeLiblsl)
+        LslStreamOutlet.lsl = this.fakeLiblsl
     }
 
     @test()
@@ -175,7 +170,7 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
     protected static async constructionCreatesStreamInfo() {
         await this.LslStreamOutlet()
 
-        assert.isEqualDeep(FakeStreamInfo.callsToConstructor[0], {
+        assert.isEqualDeep(FakeLslInfo.callsToConstructor[0], {
             channelNames: this.randomOutletOptions.channelNames,
             channelFormat: this.randomOutletOptions.channelFormat,
             sampleRateHz: this.randomOutletOptions.sampleRateHz,
@@ -241,9 +236,9 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
     protected static async pushSampleHandlesErrorCode() {
         let passedErrorCode: number | undefined
 
-        setOutletHandleLslError((errorCode: number) => {
+        LslStreamOutlet.handleLslError = (errorCode: number) => {
             passedErrorCode = errorCode
-        })
+        }
 
         FakeLiblsl.fakeErrorCode = [-4, -3, -2, -1, 0][
             Math.floor(Math.random() * 5)
@@ -265,11 +260,12 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
 
     @test()
     protected static async waitsForTenMsAfterConstructionBeforeReturning() {
-        const startMs = Date.now()
-        await this.LslStreamOutlet({ waitAfterConstructionMs: 10 })
-        const endMs = Date.now()
+        await this.LslStreamOutlet()
 
-        assert.isAbove(endMs - startMs, 8)
+        assert.isTruthy(
+            this.callsToSetTimeout.includes(10),
+            'Did not wait for 10ms after construction!'
+        )
     }
 
     @test()
@@ -345,7 +341,7 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
     }
 
     private static async createAndAssertThrows(
-        option: keyof StreamOutletOptions,
+        option: keyof LslOutletOptions,
         value: number | string[] | ChannelFormat,
         expectedMessage: string
     ) {
@@ -367,9 +363,7 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
         return await this.LslStreamOutlet({ channelFormat: 'float32' })
     }
 
-    private static async LslStreamOutlet(
-        options?: Partial<StreamOutletOptions>
-    ) {
+    private static async LslStreamOutlet(options?: Partial<LslOutletOptions>) {
         return await LslStreamOutlet.Create({
             ...this.randomOutletOptions,
             ...options,
@@ -378,7 +372,7 @@ export default class LslStreamOutletTest extends AbstractPackageTest {
 }
 
 class CheckingOutlet extends LslStreamOutlet {
-    public constructor(options: StreamOutletOptions) {
+    public constructor(options: LslOutletOptions) {
         super(options)
     }
 }

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

@@ -2,30 +2,29 @@ import { randomInt } from 'node:crypto'
 
 import { test, assert } from '@neurodevs/node-tdd'
 
-import { StreamInletOptions } from '../../impl/LslStreamInlet.js'
+import { LslInletOptions } from '../../impl/LslStreamInlet.js'
 import LslWebSocketBridge, {
-    WebSocketBridgeOptions,
+    LslWsBridgeOptions,
 } from '../../impl/LslWebSocketBridge.js'
-import FakeStreamInlet from '../../testDoubles/StreamInlet/FakeStreamInlet.js'
-import SpyLslWebSocketBridge from '../../testDoubles/WebSocketBridge/SpyLslWebSocketBridge.js'
+import FakeLslInlet from '../../testDoubles/LslInlet/FakeLslInlet.js'
+import SpyLslWsBridge from '../../testDoubles/LslWsBridge/SpyLslWsBridge.js'
 import FakeWebSocket from '../../testDoubles/WebSockets/FakeWebSocket.js'
 import FakeWebSocketServer from '../../testDoubles/WebSockets/FakeWebSocketServer.js'
 import AbstractPackageTest from '../AbstractPackageTest.js'
 
 export default class LslWebSocketBridgeTest extends AbstractPackageTest {
-    private static instance: SpyLslWebSocketBridge
+    private static instance: SpyLslWsBridge
 
     protected static async beforeEach() {
         await super.beforeEach()
 
         this.setFakeLiblsl()
-        this.setFakeStreamInlet()
+        this.setFakeLslInlet()
         this.setFakeWebSocket()
         this.setFakeWebSocketServer()
-        this.setSpyLslWebSocketBridge()
+        this.setSpyLslWsBridge()
 
-        this.instance =
-            (await this.LslWebSocketBridge()) as SpyLslWebSocketBridge
+        this.instance = (await this.LslWebSocketBridge()) as SpyLslWsBridge
     }
 
     @test()
@@ -35,7 +34,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
 
     @test()
     protected static async createsLslStreamInlet() {
-        const call = FakeStreamInlet.callsToConstructor[0]
+        const call = FakeLslInlet.callsToConstructor[0]
 
         const sourceId = call.options!.sourceId
         const chunkSize = call.options!.chunkSize
@@ -54,7 +53,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         await this.activate()
 
         assert.isEqual(
-            FakeStreamInlet.numCallsToStartPulling,
+            FakeLslInlet.numCallsToStartPulling,
             1,
             'Did not call startPulling on inlet!'
         )
@@ -66,7 +65,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         this.deactivate()
 
         assert.isEqual(
-            FakeStreamInlet.numCallsToStopPulling,
+            FakeLslInlet.numCallsToStopPulling,
             1,
             'Did not call stopPulling on inlet!'
         )
@@ -77,7 +76,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         this.destroy()
 
         assert.isEqual(
-            FakeStreamInlet.numCallsToDestroy,
+            FakeLslInlet.numCallsToDestroy,
             1,
             'Did not call destroy on inlet!'
         )
@@ -270,7 +269,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         const samples = [...new Float32Array([1, 2, 3, 4, 5, 6])]
         const timestamps = [...new Float64Array([7, 8])]
 
-        FakeStreamInlet.callsToConstructor[0]?.onData!(samples, timestamps)
+        FakeLslInlet.callsToConstructor[0]?.onData!(samples, timestamps)
         return { samples, timestamps }
     }
 
@@ -278,7 +277,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
 
     private static readonly connectUrls = [this.generateId(), this.generateId()]
 
-    private static readonly inletOptions: StreamInletOptions = {
+    private static readonly inletOptions: LslInletOptions = {
         sourceId: this.sourceId,
         chunkSize: randomInt(1, 100),
     }
@@ -289,9 +288,7 @@ export default class LslWebSocketBridgeTest extends AbstractPackageTest {
         connectUrls: this.connectUrls,
     }
 
-    private static LslWebSocketBridge(
-        options?: Partial<WebSocketBridgeOptions>
-    ) {
+    private static LslWebSocketBridge(options?: Partial<LslWsBridgeOptions>) {
         return LslWebSocketBridge.Create({ ...this.baseOptions, ...options })
     }
 }

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

@@ -0,0 +1,109 @@
+import { test, assert } from '@neurodevs/node-tdd'
+
+import UsbDeviceController, {
+    UsbController,
+} from '../../impl/controllers/UsbDeviceController.js'
+import AbstractPackageTest from '../AbstractPackageTest.js'
+import { FakeLibndx } from '@neurodevs/ndx-native'
+
+export default class UsbDeviceControllerTest extends AbstractPackageTest {
+    private static instance: UsbController
+
+    private static readonly serialNumber = this.generateId()
+    private static readonly valueToWrite = this.generateId()
+
+    private static readonly callsToOnData: {
+        data: Buffer
+        length: number
+        timestampSec: number
+    }[] = []
+
+    private static readonly onData = (
+        data: Buffer,
+        length: number,
+        timestampSec: number
+    ) => {
+        this.callsToOnData.push({ data, length, timestampSec })
+    }
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+
+        this.instance = this.UsbDeviceController()
+    }
+
+    @test()
+    protected static async createsInstance() {
+        assert.isTruthy(this.instance, 'Failed to create instance!')
+    }
+
+    @test()
+    protected static async connectCallsLibndxCreateUsbBackend() {
+        await this.connect()
+
+        assert.isEqualDeep(
+            FakeLibndx.callsToCreateUsbBackend[0],
+            {
+                serialNumber: this.serialNumber,
+            },
+            'Did not call create_usb_backend!'
+        )
+    }
+
+    @test()
+    protected static async connectCallsLibndxStartUsbBackend() {
+        await this.connect()
+
+        assert.isEqualDeep(
+            FakeLibndx.callsToStartUsbBackend[0],
+            {
+                serialNumber: this.serialNumber,
+                onData: this.onData,
+            },
+            'Did not call start_usb_backend!'
+        )
+    }
+
+    @test()
+    protected static async disconnectCallsLibndxStopUsbBackend() {
+        await this.connect()
+        await this.disconnect()
+
+        assert.isEqualDeep(
+            FakeLibndx.callsToStopUsbBackend[0],
+            {
+                serialNumber: this.serialNumber,
+            },
+            'Did not call stop_usb_backend!'
+        )
+    }
+
+    @test()
+    protected static async writeUsbCallsLibndxWriteUsbBackend() {
+        await this.instance.writeUsb(this.valueToWrite)
+
+        assert.isEqualDeep(
+            FakeLibndx.callsToWriteUsbBackend[0],
+            {
+                serialNumber: this.serialNumber,
+                value: this.valueToWrite,
+            },
+            'Did not call write_usb_backend!'
+        )
+    }
+
+    private static async connect() {
+        await this.instance.connect()
+    }
+
+    private static async disconnect() {
+        await this.instance.disconnect()
+    }
+
+    private static UsbDeviceController() {
+        return UsbDeviceController.Create({
+            onData: this.onData,
+            serialNumber: this.serialNumber,
+        })
+    }
+}