valenceai 0.5.1 → 1.0.1

package/tests/streaming.test.js

@@ -0,0 +1,187 @@
+import { describe, test, expect, jest, beforeEach, afterEach } from '@jest/globals';
+import { ValenceClient } from '../src/valenceClient.js';
+
+// Mock socket.io-client
+const mockSocket = {
+  connect: jest.fn(),
+  emit: jest.fn(),
+  on: jest.fn(),
+  disconnect: jest.fn(),
+  connected: false
+};
+
+jest.unstable_mockModule('socket.io-client', () => ({
+  io: jest.fn(() => mockSocket)
+}));
+
+describe('Streaming API', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+    process.env.VALENCE_API_KEY = 'test-api-key';
+    process.env.VALENCE_WEBSOCKET_URL = 'wss://test-api.com';
+    jest.clearAllMocks();
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  test('should have streaming property', () => {
+    const client = new ValenceClient({ apiKey: 'test-key' });
+    expect(client).toHaveProperty('streaming');
+    expect(typeof client.streaming.connect).toBe('function');
+  });
+
+  test('should create StreamConnection with default model', () => {
+    const client = new ValenceClient({ apiKey: 'test-key' });
+    const stream = client.streaming.connect();
+
+    expect(stream).toBeDefined();
+    expect(stream.model).toBe('4emotions');
+  });
+
+  test('should create StreamConnection with custom model', () => {
+    const client = new ValenceClient({ apiKey: 'test-key' });
+    const stream = client.streaming.connect('7emotions');
+
+    expect(stream).toBeDefined();
+    expect(stream.model).toBe('7emotions');
+  });
+
+  test('should throw error for invalid model', () => {
+    const client = new ValenceClient({ apiKey: 'test-key' });
+
+    expect(() => {
+      client.streaming.connect('invalid_model');
+    }).toThrow('Invalid model');
+  });
+
+  test('should use custom WebSocket URL', () => {
+    const client = new ValenceClient({
+      apiKey: 'test-key',
+      websocketUrl: 'wss://custom.example.com'
+    });
+    const stream = client.streaming.connect();
+
+    expect(stream.websocketUrl).toBe('wss://custom.example.com');
+  });
+
+  test('StreamConnection should have required methods', () => {
+    const client = new ValenceClient({ apiKey: 'test-key' });
+    const stream = client.streaming.connect();
+
+    expect(typeof stream.connect).toBe('function');
+    expect(typeof stream.sendAudio).toBe('function');
+    expect(typeof stream.disconnect).toBe('function');
+    expect(typeof stream.onPrediction).toBe('function');
+    expect(typeof stream.onError).toBe('function');
+  });
+
+  test('should register prediction callback', () => {
+    const client = new ValenceClient({ apiKey: 'test-key' });
+    const stream = client.streaming.connect();
+
+    const callback = jest.fn();
+    stream.onPrediction(callback);
+
+    expect(stream.predictionCallback).toBe(callback);
+  });
+
+  test('should register error callback', () => {
+    const client = new ValenceClient({ apiKey: 'test-key' });
+    const stream = client.streaming.connect();
+
+    const callback = jest.fn();
+    stream.onError(callback);
+
+    expect(stream.errorCallback).toBe(callback);
+  });
+
+  test('should register connect callback', () => {
+    const client = new ValenceClient({ apiKey: 'test-key' });
+    const stream = client.streaming.connect();
+
+    const callback = jest.fn();
+    stream.onConnect(callback);
+
+    expect(stream.connectCallback).toBe(callback);
+  });
+
+  test('should register disconnect callback', () => {
+    const client = new ValenceClient({ apiKey: 'test-key' });
+    const stream = client.streaming.connect();
+
+    const callback = jest.fn();
+    stream.onDisconnect(callback);
+
+    expect(stream.disconnectCallback).toBe(callback);
+  });
+
+  test('should encode audio data to base64', () => {
+    const client = new ValenceClient({ apiKey: 'test-key' });
+    const stream = client.streaming.connect();
+
+    const audioBuffer = Buffer.from([0x00, 0x01, 0x02, 0x03]);
+    const base64 = stream._encodeAudio(audioBuffer);
+
+    expect(typeof base64).toBe('string');
+    expect(base64).toBe(audioBuffer.toString('base64'));
+  });
+
+  test('should handle connection with API key', () => {
+    const client = new ValenceClient({ apiKey: 'test-api-key' });
+    const stream = client.streaming.connect();
+
+    expect(stream.apiKey).toBe('test-api-key');
+  });
+
+  test('should use default WebSocket URL when not specified', () => {
+    const client = new ValenceClient({ apiKey: 'test-key' });
+    const stream = client.streaming.connect();
+
+    // Should use the default staging URL
+    expect(stream.websocketUrl).toBe('wss://demo.getvalenceai.com');
+  });
+
+  test('should validate model parameter', () => {
+    const client = new ValenceClient({ apiKey: 'test-key' });
+
+    // Valid models
+    expect(() => client.streaming.connect('4emotions')).not.toThrow();
+    expect(() => client.streaming.connect('7emotions')).not.toThrow();
+
+    // Invalid model
+    expect(() => client.streaming.connect('invalid')).toThrow('Invalid model');
+    expect(() => client.streaming.connect('')).toThrow('Invalid model');
+    expect(() => client.streaming.connect(null)).toThrow('Invalid model');
+  });
+
+  test('should throw error if sendAudio called before connect', () => {
+    const client = new ValenceClient({ apiKey: 'test-key' });
+    const stream = client.streaming.connect();
+
+    const audioData = Buffer.from([0x00, 0x01]);
+
+    expect(() => {
+      stream.sendAudio(audioData);
+    }).toThrow('Not connected');
+  });
+
+  test('should validate audio data in sendAudio', () => {
+    const client = new ValenceClient({ apiKey: 'test-key' });
+    const stream = client.streaming.connect();
+
+    // Mock connection
+    stream.sio = { connected: true, emit: jest.fn() };
+
+    expect(() => {
+      stream.sendAudio(null);
+    }).toThrow('Audio data is required');
+
+    expect(() => {
+      stream.sendAudio(undefined);
+    }).toThrow('Audio data is required');
+  });
+});

package/tests/valenceClient.test.js

@@ -2,20 +2,65 @@ import { describe, test, expect } from '@jest/globals';
 import { ValenceClient } from '../src/valenceClient.js';
 
 describe('ValenceClient', () => {
-  test('should create client with nested discrete and asynch properties', () => {
-    const client = new ValenceClient();
-    
+  test('should create client with all nested API properties', () => {
+    const client = new ValenceClient({ apiKey: 'test_key' });
+
+    // Check all four API clients
     expect(client).toHaveProperty('discrete');
     expect(client).toHaveProperty('asynch');
+    expect(client).toHaveProperty('streaming');
+    expect(client).toHaveProperty('rateLimit');
+
+    // Check discrete methods
     expect(typeof client.discrete.emotions).toBe('function');
+
+    // Check asynch methods
     expect(typeof client.asynch.upload).toBe('function');
     expect(typeof client.asynch.emotions).toBe('function');
+    expect(typeof client.asynch.getTimeline).toBe('function');
+    expect(typeof client.asynch.getEmotionAtTime).toBe('function');
+    expect(typeof client.asynch.getDominantEmotion).toBe('function');
+
+    // Check streaming methods
+    expect(typeof client.streaming.connect).toBe('function');
+
+    // Check rate limit methods
+    expect(typeof client.rateLimit.getStatus).toBe('function');
+    expect(typeof client.rateLimit.getHealth).toBe('function');
+  });
+
+  test('should use default staging URLs', () => {
+    const client = new ValenceClient({ apiKey: 'test_key' });
+
+    expect(client.config.baseUrl).toBe('https://demo.getvalenceai.com');
+    expect(client.config.websocketUrl).toBe('wss://demo.getvalenceai.com');
+  });
+
+  test('should accept custom URLs via constructor', () => {
+    const client = new ValenceClient({
+      apiKey: 'test_key',
+      baseUrl: 'https://custom.example.com',
+      websocketUrl: 'wss://custom.example.com'
+    });
+
+    expect(client.config.baseUrl).toBe('https://custom.example.com');
+    expect(client.config.websocketUrl).toBe('wss://custom.example.com');
   });
 
   test('should pass constructor parameters to AsyncClient', () => {
-    const client = new ValenceClient(1024, 5);
-    
+    const client = new ValenceClient({
+      apiKey: 'test_key',
+      partSize: 1024,
+      maxRetries: 5
+    });
+
     expect(client.asynch.partSize).toBe(1024);
     expect(client.asynch.maxRetries).toBe(5);
   });
+
+  test('should throw error when API key is missing', () => {
+    expect(() => {
+      new ValenceClient({ apiKey: '' });
+    }).toThrow('API key not provided and not set in environment (VALENCE_API_KEY)');
+  });
 });