@inferencesh/sdk 0.1.0 → 0.1.3

package/dist/stream.test.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const stream_1 = require("./stream");
+describe('StreamManager', () => {
+    let mockEventSource;
+    beforeEach(() => {
+        mockEventSource = {
+            onmessage: null,
+            onerror: null,
+            close: jest.fn(),
+        };
+    });
+    describe('constructor', () => {
+        it('should create instance with default options', () => {
+            const manager = new stream_1.StreamManager({
+                createEventSource: async () => mockEventSource,
+            });
+            expect(manager).toBeDefined();
+        });
+    });
+    describe('connect', () => {
+        it('should call createEventSource', async () => {
+            const createEventSource = jest
+                .fn()
+                .mockResolvedValue(mockEventSource);
+            const manager = new stream_1.StreamManager({ createEventSource });
+            await manager.connect();
+            expect(createEventSource).toHaveBeenCalled();
+        });
+        it('should call onStart when connected', async () => {
+            const onStart = jest.fn();
+            const manager = new stream_1.StreamManager({
+                createEventSource: async () => mockEventSource,
+                onStart,
+            });
+            await manager.connect();
+            expect(onStart).toHaveBeenCalled();
+        });
+        it('should parse JSON messages and call onData', async () => {
+            const onData = jest.fn();
+            const manager = new stream_1.StreamManager({
+                createEventSource: async () => mockEventSource,
+                onData,
+            });
+            await manager.connect();
+            // Simulate receiving a message
+            const testData = { status: 'running', id: 'task-123' };
+            mockEventSource.onmessage?.({ data: JSON.stringify(testData) });
+            expect(onData).toHaveBeenCalledWith(testData);
+        });
+        it('should extract data from partial data wrapper and call onData', async () => {
+            const onData = jest.fn();
+            const manager = new stream_1.StreamManager({
+                createEventSource: async () => mockEventSource,
+                onData,
+            });
+            await manager.connect();
+            // Simulate receiving a partial data wrapper from server
+            const innerData = { status: 7, id: 'task-123', logs: ['log1'] };
+            const partialWrapper = { data: innerData, fields: ['status', 'logs'] };
+            mockEventSource.onmessage?.({ data: JSON.stringify(partialWrapper) });
+            // onData should receive the extracted inner data, not the wrapper
+            expect(onData).toHaveBeenCalledWith(innerData);
+        });
+        it('should call onPartialData with data and fields for partial updates', async () => {
+            const onData = jest.fn();
+            const onPartialData = jest.fn();
+            const manager = new stream_1.StreamManager({
+                createEventSource: async () => mockEventSource,
+                onData,
+                onPartialData,
+            });
+            await manager.connect();
+            // Simulate receiving a partial data wrapper
+            const innerData = { status: 7, id: 'task-123' };
+            const fields = ['status'];
+            const partialWrapper = { data: innerData, fields };
+            mockEventSource.onmessage?.({ data: JSON.stringify(partialWrapper) });
+            expect(onPartialData).toHaveBeenCalledWith(innerData, fields);
+            expect(onData).toHaveBeenCalledWith(innerData);
+        });
+        it('should not call onPartialData for non-partial data', async () => {
+            const onData = jest.fn();
+            const onPartialData = jest.fn();
+            const manager = new stream_1.StreamManager({
+                createEventSource: async () => mockEventSource,
+                onData,
+                onPartialData,
+            });
+            await manager.connect();
+            // Regular data without partial wrapper
+            const regularData = { status: 9, id: 'task-123' };
+            mockEventSource.onmessage?.({ data: JSON.stringify(regularData) });
+            expect(onPartialData).not.toHaveBeenCalled();
+            expect(onData).toHaveBeenCalledWith(regularData);
+        });
+        it('should call onError for invalid JSON', async () => {
+            const onError = jest.fn();
+            const manager = new stream_1.StreamManager({
+                createEventSource: async () => mockEventSource,
+                onError,
+            });
+            await manager.connect();
+            mockEventSource.onmessage?.({ data: 'invalid json' });
+            expect(onError).toHaveBeenCalled();
+        });
+    });
+    describe('stop', () => {
+        it('should close the event source', async () => {
+            const onStop = jest.fn();
+            const manager = new stream_1.StreamManager({
+                createEventSource: async () => mockEventSource,
+                onStop,
+            });
+            await manager.connect();
+            manager.stop();
+            expect(mockEventSource.close).toHaveBeenCalled();
+            expect(onStop).toHaveBeenCalled();
+        });
+        it('should not process messages after stop', async () => {
+            const onData = jest.fn();
+            const manager = new stream_1.StreamManager({
+                createEventSource: async () => mockEventSource,
+                onData,
+            });
+            await manager.connect();
+            manager.stop();
+            mockEventSource.onmessage?.({ data: '{"status":"running"}' });
+            expect(onData).not.toHaveBeenCalled();
+        });
+    });
+    describe('reconnection', () => {
+        it('should attempt reconnection on error when autoReconnect is true', async () => {
+            jest.useFakeTimers();
+            const createEventSource = jest
+                .fn()
+                .mockResolvedValue(mockEventSource);
+            const manager = new stream_1.StreamManager({
+                createEventSource,
+                autoReconnect: true,
+                reconnectDelayMs: 100,
+            });
+            await manager.connect();
+            expect(createEventSource).toHaveBeenCalledTimes(1);
+            // Simulate error
+            mockEventSource.onerror?.({});
+            // Fast-forward past reconnect delay
+            jest.advanceTimersByTime(100);
+            await Promise.resolve(); // Flush promises
+            expect(createEventSource).toHaveBeenCalledTimes(2);
+            jest.useRealTimers();
+        });
+        it('should not reconnect when autoReconnect is false', async () => {
+            const createEventSource = jest
+                .fn()
+                .mockResolvedValue(mockEventSource);
+            const manager = new stream_1.StreamManager({
+                createEventSource,
+                autoReconnect: false,
+            });
+            await manager.connect();
+            mockEventSource.onerror?.({});
+            // Wait a bit
+            await new Promise((r) => setTimeout(r, 50));
+            expect(createEventSource).toHaveBeenCalledTimes(1);
+        });
+    });
+});