@neurodevs/node-lsl 17.1.1 → 18.1.0

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

@@ -0,0 +1,323 @@
+import { randomInt } from 'node:crypto'
+
+import { assert, test } from '@neurodevs/node-tdd'
+
+import LslEventMarkerEmitter, {
+    EventMarkerOptions,
+} from '../../impl/LslEventMarkerEmitter.js'
+import { StreamOutletOptions } from '../../impl/LslStreamOutlet.js'
+import SpyEventMarkerEmitter from '../../testDoubles/EventMarkerEmitter/SpyEventMarkerEmitter.js'
+import generateRandomOutletOptions from '../../testDoubles/generateRandomOutletOptions.js'
+import FakeStreamOutlet from '../../testDoubles/StreamOutlet/FakeStreamOutlet.js'
+import AbstractPackageTest from '../AbstractPackageTest.js'
+
+export default class EventMarkerEmitterTest extends AbstractPackageTest {
+    private static instance: SpyEventMarkerEmitter
+
+    protected static async beforeEach() {
+        await super.beforeEach()
+
+        this.setFakeLiblsl()
+        this.setFakeStreamOutlet()
+        this.setSpyEventMarkerEmitter()
+
+        this.instance = await this.LslEventMarkerEmitter()
+    }
+
+    private static readonly markerName = this.generateId()
+
+    @test()
+    protected static async createsInstance() {
+        assert.isTruthy(this.instance, 'Failed to create instance!')
+    }
+
+    @test()
+    protected static async loadsWithEventMarkerSpecificOptions() {
+        assert.isEqualDeep(
+            {
+                ...FakeStreamOutlet.callsToConstructor[0],
+                name: undefined,
+                sourceId: undefined,
+            },
+            {
+                name: undefined,
+                type: 'Markers',
+                sourceId: undefined,
+                channelNames: ['Markers'],
+                channelFormat: 'string',
+                sampleRateHz: 0,
+                chunkSize: 1,
+            }
+        )
+
+        assert.isTrue(
+            FakeStreamOutlet.callsToConstructor[0]?.sourceId.startsWith(
+                'event-markers-'
+            ),
+            'Source ID was not generated uniquely!'
+        )
+
+        assert.isTrue(
+            FakeStreamOutlet.callsToConstructor[0]?.name.startsWith(
+                'Event markers ('
+            ),
+            'Name was not generated uniquely!'
+        )
+    }
+
+    @test()
+    protected static async canOverrideDefaultOptions() {
+        const options = generateRandomOutletOptions()
+        await this.LslEventMarkerEmitter(options)
+
+        assert.isEqualDeep(FakeStreamOutlet.callsToConstructor[1], options)
+    }
+
+    @test()
+    protected static async emittingSingleMarkerIncrementsHitCountAndWaitTime() {
+        const markers = [this.generateEventMarker()]
+        await this.instance.emitMany(markers)
+
+        const marker = markers[0]
+
+        assert.isEqual(
+            FakeStreamOutlet.callsToPushSample[0]?.sample[0],
+            marker.name,
+            'Pushed the wrong marker!'
+        )
+
+        assert.isEqual(this.instance.totalwaitAfterMs, marker.waitAfterMs)
+    }
+
+    @test()
+    protected static async emittingTwoMarkersIncrementsHitCountAndWaitTimeTwice() {
+        const markers = await this.emitManyFor(2)
+
+        assert.isEqual(FakeStreamOutlet.callsToPushSample.length, 2)
+
+        assert.isEqual(
+            this.instance.totalwaitAfterMs,
+            markers[0].waitAfterMs + markers[1].waitAfterMs
+        )
+    }
+
+    @test('interrupts on first marker', 1)
+    @test('interrupts on second marker', 2)
+    @test('interrupts on third marker', 3)
+    protected static async emitterIsInterruptable(bailIdx: number) {
+        let hitCount = 0
+
+        this.streamOutlet.pushSample = () => {
+            hitCount += 1
+            if (hitCount === bailIdx) {
+                this.interrupt()
+            }
+        }
+
+        await this.emitManyFor(10)
+
+        assert.isEqual(hitCount, bailIdx)
+    }
+
+    @test()
+    protected static async canStartAgainAfterInterrupting() {
+        this.interrupt()
+
+        let hitCount = 0
+
+        this.streamOutlet.pushSample = () => {
+            hitCount++
+        }
+
+        await this.emitManyFor(10)
+
+        assert.isEqual(hitCount, 10)
+    }
+
+    @test()
+    protected static async doesNotWaitIfInterrupted() {
+        await this.setupOutlet()
+
+        const startMs = Date.now()
+        const promise = this.emitManyFor(2, 1000)
+        this.interrupt()
+        await promise
+        const endMs = Date.now()
+
+        assert.isBelow(endMs - startMs, 10)
+    }
+
+    @test()
+    protected static async clearsTimeoutOnInterrupt() {
+        void this.emitManyFor(2, 100)
+        this.interrupt()
+
+        this.streamOutlet.pushSample = () =>
+            assert.fail('Should not have been called')
+    }
+
+    @test()
+    protected static async emitCallsPushSampleOnStreamOutlet() {
+        const markerName = this.generateId()
+        await this.emit(markerName)
+
+        assert.isEqualDeep(
+            FakeStreamOutlet.callsToPushSample[0]?.sample,
+            [markerName],
+            'Pushed the wrong sample!'
+        )
+    }
+
+    @test()
+    protected static async emitWaitsForMsIfPassed() {
+        SpyEventMarkerEmitter.shouldCallWaitOnSuper = true
+
+        const waitAfterMs = 10
+
+        const startMs = Date.now()
+        await this.instance.emit(this.markerName, { waitAfterMs })
+        const endMs = Date.now()
+
+        assert.isAbove(
+            endMs - startMs,
+            0.8 * waitAfterMs,
+            'Did not wait for the specified time!'
+        )
+    }
+
+    @test()
+    protected static async destroyCallsDestroyOnInternalStreamOutlet() {
+        this.destroy()
+
+        assert.isEqual(
+            FakeStreamOutlet.numCallsToDestroy,
+            1,
+            'Did not call destroy on outlet!'
+        )
+    }
+
+    @test()
+    protected static async destroyInterruptsIfRunning() {
+        let wasHit = false
+
+        const original = this.instance.interrupt.bind(this.instance)
+
+        this.instance.interrupt = () => {
+            wasHit = true
+            original()
+        }
+
+        const promise = this.emitManyFor(5, 10)
+        this.destroy()
+
+        assert.isTrue(wasHit, 'Did not call interrupt on destroy!')
+
+        await promise
+    }
+
+    @test()
+    protected static async sourceIdIsUniqueAcrossInstances() {
+        const instance = await this.LslEventMarkerEmitter()
+
+        assert.isNotEqual(
+            instance['outlet'].sourceId,
+            this.instance['outlet'].sourceId,
+            'Source IDs are not unique!'
+        )
+    }
+
+    @test()
+    protected static async emitThrowsIfCalledWhileAlreadyRunning() {
+        void this.instance.emit(this.markerName, { waitAfterMs: 10 })
+
+        await assert.doesThrowAsync(async () => {
+            await this.emit(this.generateId())
+        }, 'Cannot call emit while already running!')
+    }
+
+    @test()
+    protected static async emitManyThrowsIfCalledWhileAlreadyRunning() {
+        void EventMarkerEmitterTest.emitManyOnce()
+
+        await assert.doesThrowAsync(async () => {
+            await this.emitManyFor(5, 1)
+        }, 'Cannot call emitMany while already running!')
+    }
+
+    @test()
+    protected static async emitSetsIsRunningFalseOnceDone() {
+        await this.emitOnce()
+
+        assert.isFalse(
+            this.instance['isRunning'],
+            'emit did not set isRunning to false once done!'
+        )
+    }
+
+    @test()
+    protected static async emitManySetsIsRunningFalseOnceDone() {
+        await this.emitManyOnce()
+
+        assert.isFalse(
+            this.instance['isRunning'],
+            'emitMany did not set isRunning to false once done! '
+        )
+    }
+
+    private static async emitOnce() {
+        await this.emit(this.markerName)
+    }
+
+    private static async emit(
+        markerName: string,
+        options?: EventMarkerOptions
+    ) {
+        return this.instance.emit(markerName, options)
+    }
+
+    private static async emitManyOnce() {
+        return this.emitManyFor(5, 1)
+    }
+
+    private static async emitManyFor(total: number, waitAfterMs?: number) {
+        const markers = new Array(total)
+            .fill(null)
+            .map(() => this.generateEventMarker(waitAfterMs))
+
+        await this.instance.emitMany(markers)
+
+        return markers
+    }
+
+    private static generateEventMarker(waitAfterMs?: number) {
+        return {
+            name: this.generateId(),
+            waitAfterMs: waitAfterMs ?? randomInt(100, 1000),
+        }
+    }
+
+    private static interrupt() {
+        this.instance.interrupt()
+    }
+
+    private static destroy() {
+        this.instance.destroy()
+    }
+
+    private static get streamOutlet() {
+        return this.instance.getStreamOutlet()
+    }
+
+    private static async setupOutlet() {
+        LslEventMarkerEmitter.Class = LslEventMarkerEmitter as any
+        this.instance = await this.LslEventMarkerEmitter()
+    }
+
+    private static async LslEventMarkerEmitter(
+        options?: Partial<StreamOutletOptions>
+    ) {
+        return (await LslEventMarkerEmitter.Create(
+            options
+        )) as SpyEventMarkerEmitter
+    }
+}

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

@@ -196,7 +196,7 @@ export default class LslStreamInfoTest extends AbstractPackageTest {
         assert.isEqualDeep(
             this.fakeLiblsl.lastAppendChannelsToStreamInfoOptions,
             {
-                info: this.instance.boundInfo,
+                infoHandle: this.instance.infoHandle,
                 channels: this.channelNames.map((label: string) => ({
                     label,
                     units: this.units,
@@ -212,49 +212,12 @@ export default class LslStreamInfoTest extends AbstractPackageTest {
         this.instance.destroy()
 
         assert.isEqualDeep(
-            this.fakeLiblsl.lastDestroyStreamInfoOptions?.info,
-            this.instance.boundInfo,
+            this.fakeLiblsl.lastDestroyStreamInfoOptions?.infoHandle,
+            this.instance.infoHandle,
             'Should have called destroyStreamInfo!'
         )
     }
 
-    @test()
-    protected static async doesNotCreateNewStreamInfoIfPassedBoundInfo() {
-        this.LslStreamInfo({
-            boundInfo: this.instance.boundInfo,
-        })
-
-        assert.isEqual(
-            this.fakeLiblsl.createStreamInfoHitCount,
-            1,
-            'Should not have created new stream info!'
-        )
-    }
-
-    @test()
-    protected static async setsBoundInfoWhenPassed() {
-        const instance = this.LslStreamInfo({
-            boundInfo: this.instance.boundInfo,
-        })
-
-        assert.isEqualDeep(
-            instance.boundInfo,
-            this.instance.boundInfo,
-            'Should have set bound stream info!'
-        )
-    }
-
-    @test()
-    protected static async cachesInfoAttributesByBoundInfo() {
-        const cached = LslStreamInfo.From(this.instance.boundInfo)
-
-        assert.isEqualDeep(
-            cached,
-            this.instance,
-            'Should have set bound stream info!'
-        )
-    }
-
     private static readonly defaultOptions = {
         name: this.name,
         type: this.type,