valenceai 0.4.0

package/tests/asyncAudio.test.js

@@ -0,0 +1,331 @@
+import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import nock from 'nock';
+import fs from 'fs';
+import { ValenceClient } from '../src/valenceClient.js';
+
+describe('AsyncAudio', () => {
+  const originalEnv = process.env;
+  let fsMock, statMock;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+    process.env.VALENCE_API_KEY = 'test-api-key';
+    process.env.VALENCE_ASYNC_URL = 'https://test-api.com';
+    
+    fsMock = jest.spyOn(fs, 'existsSync');
+    statMock = jest.spyOn(fs, 'statSync');
+    
+    // Mock createReadStream to simulate file chunks
+    jest.spyOn(fs, 'createReadStream').mockReturnValue({
+      [Symbol.asyncIterator]: async function* () {
+        yield Buffer.from('chunk1');
+        yield Buffer.from('chunk2');
+      }
+    });
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+    jest.restoreAllMocks();
+    nock.cleanAll();
+  });
+
+  describe('uploadAsyncAudio', () => {
+    test('should successfully upload async audio', async () => {
+      fsMock.mockReturnValue(true);
+      statMock.mockReturnValue({ size: 10485760 }); // 10MB
+      
+      const mockInitiateResponse = {
+        request_id: 'req-123',
+        upload_id: 'upload-123',
+        presigned_urls: [
+          { part_number: 1, url: 'https://s3.test.com/part1' },
+          { part_number: 2, url: 'https://s3.test.com/part2' }
+        ]
+      };
+
+      // Mock initiate request
+      nock('https://test-api.com')
+        .get('/upload/initiate')
+        .query({ file_name: 'test.wav', part_count: 2 })
+        .reply(200, mockInitiateResponse);
+
+      // Mock S3 uploads
+      nock('https://s3.test.com')
+        .put('/part1')
+        .reply(200, '', { etag: '"etag1"' });
+      
+      nock('https://s3.test.com')
+        .put('/part2')
+        .reply(200, '', { etag: '"etag2"' });
+
+      // Mock complete request
+      nock('https://test-api.com')
+        .post('/upload/complete', {
+          request_id: 'req-123',
+          upload_id: 'upload-123',
+          parts: [
+            { ETag: '"etag1"', PartNumber: 1 },
+            { ETag: '"etag2"', PartNumber: 2 }
+          ]
+        })
+        .reply(200);
+
+      const client = new ValenceClient();
+      const result = await client.asynch.upload('test.wav');
+      
+      expect(result).toBe('req-123');
+    });
+
+    test('should throw error when filePath is missing', async () => {
+      const client = new ValenceClient();
+      await expect(client.asynch.upload()).rejects.toThrow(
+        'filePath is required and must be a string'
+      );
+    });
+
+    test('should throw error when filePath is not a string', async () => {
+      const client = new ValenceClient();
+      await expect(client.asynch.upload(123)).rejects.toThrow(
+        'filePath is required and must be a string'
+      );
+    });
+
+    test('should throw error when API key is missing', async () => {
+      delete process.env.VALENCE_API_KEY;
+      
+      const client = new ValenceClient();
+      await expect(client.asynch.upload('test.wav')).rejects.toThrow(
+        'VALENCE_API_KEY is required'
+      );
+    });
+
+    test('should throw error when file does not exist', async () => {
+      fsMock.mockReturnValue(false);
+      
+      const client = new ValenceClient();
+      await expect(client.asynch.upload('nonexistent.wav')).rejects.toThrow(
+        'File not found: nonexistent.wav'
+      );
+    });
+
+    test('should throw error with invalid partSize', async () => {
+      fsMock.mockReturnValue(true);
+      
+      const client = new ValenceClient();
+      await expect(client.asynch.upload('test.wav', 500000)).rejects.toThrow(
+        'partSize must be between 1MB and 100MB'
+      );
+      
+      await expect(client.asynch.upload('test.wav', 200 * 1024 * 1024)).rejects.toThrow(
+        'partSize must be between 1MB and 100MB'
+      );
+    });
+
+    test('should handle missing presigned URLs', async () => {
+      fsMock.mockReturnValue(true);
+      statMock.mockReturnValue({ size: 5242880 }); // 5MB
+      
+      nock('https://test-api.com')
+        .get('/upload/initiate')
+        .reply(200, {
+          request_id: 'req-123',
+          upload_id: 'upload-123',
+          presigned_urls: [] // Empty array
+        });
+
+      const client = new ValenceClient();
+      await expect(client.asynch.upload('test.wav')).rejects.toThrow(
+        'Missing presigned URL for part 1'
+      );
+    });
+
+    test('should handle missing ETag in response', async () => {
+      fsMock.mockReturnValue(true);
+      statMock.mockReturnValue({ size: 5242880 }); // 5MB
+      
+      nock('https://test-api.com')
+        .get('/upload/initiate')
+        .reply(200, {
+          request_id: 'req-123',
+          upload_id: 'upload-123',
+          presigned_urls: [
+            { part_number: 1, url: 'https://s3.test.com/part1' }
+          ]
+        });
+
+      nock('https://s3.test.com')
+        .put('/part1')
+        .reply(200, ''); // No ETag header
+
+      const client = new ValenceClient();
+      await expect(client.asynch.upload('test.wav')).rejects.toThrow(
+        'Failed to get ETag for part 1'
+      );
+    });
+
+    test('should handle API errors', async () => {
+      fsMock.mockReturnValue(true);
+      statMock.mockReturnValue({ size: 5242880 });
+      
+      nock('https://test-api.com')
+        .get('/upload/initiate')
+        .reply(400, { message: 'Invalid request' });
+
+      const client = new ValenceClient();
+      await expect(client.asynch.upload('test.wav')).rejects.toThrow(
+        'API error (400): Invalid request'
+      );
+    });
+  });
+
+  describe('getEmotions', () => {
+    test('should successfully get emotions', async () => {
+      const mockResponse = {
+        emotions: {
+          happy: 0.7,
+          sad: 0.2,
+          angry: 0.1
+        }
+      };
+
+      nock('https://test-api.com')
+        .get('/prediction')
+        .query({ request_id: 'req-123' })
+        .reply(200, mockResponse);
+
+      const client = new ValenceClient();
+      const result = await client.asynch.emotions('req-123');
+      
+      expect(result).toEqual(mockResponse);
+    });
+
+    test('should poll until success', async () => {
+      const mockResponse = { emotions: { happy: 1.0 } };
+
+      nock('https://test-api.com')
+        .get('/prediction')
+        .query({ request_id: 'req-123' })
+        .reply(202) // Processing
+        .get('/prediction')
+        .query({ request_id: 'req-123' })
+        .reply(200, mockResponse); // Success
+
+      const client = new ValenceClient();
+      const result = await client.asynch.emotions('req-123', 5, 100); // Short interval for testing
+      
+      expect(result).toEqual(mockResponse);
+    });
+
+    test('should throw error when requestId is missing', async () => {
+      const client = new ValenceClient();
+      await expect(client.asynch.emotions()).rejects.toThrow(
+        'requestId is required and must be a string'
+      );
+    });
+
+    test('should throw error when requestId is not a string', async () => {
+      const client = new ValenceClient();
+      await expect(client.asynch.emotions(123)).rejects.toThrow(
+        'requestId is required and must be a string'
+      );
+    });
+
+    test('should throw error when API key is missing', async () => {
+      delete process.env.VALENCE_API_KEY;
+      
+      const client = new ValenceClient();
+      await expect(client.asynch.emotions('req-123')).rejects.toThrow(
+        'VALENCE_API_KEY is required'
+      );
+    });
+
+    test('should throw error with invalid maxTries', async () => {
+      const client = new ValenceClient();
+      await expect(client.asynch.emotions('req-123', 0)).rejects.toThrow(
+        'maxTries must be between 1 and 100'
+      );
+      
+      await expect(client.asynch.emotions('req-123', 101)).rejects.toThrow(
+        'maxTries must be between 1 and 100'
+      );
+    });
+
+    test('should throw error with invalid intervalMs', async () => {
+      const client = new ValenceClient();
+      await expect(client.asynch.emotions('req-123', 5, 500)).rejects.toThrow(
+        'intervalMs must be between 1000 and 60000'
+      );
+      
+      await expect(client.asynch.emotions('req-123', 5, 70000)).rejects.toThrow(
+        'intervalMs must be between 1000 and 60000'
+      );
+    });
+
+    test('should handle 404 errors', async () => {
+      nock('https://test-api.com')
+        .get('/prediction')
+        .query({ request_id: 'invalid-id' })
+        .reply(404);
+
+      const client = new ValenceClient();
+      await expect(client.asynch.emotions('invalid-id')).rejects.toThrow(
+        'Request ID not found: invalid-id'
+      );
+    });
+
+    test('should handle client errors', async () => {
+      nock('https://test-api.com')
+        .get('/prediction')
+        .query({ request_id: 'req-123' })
+        .reply(400, { message: 'Bad request' });
+
+      const client = new ValenceClient();
+      await expect(client.asynch.emotions('req-123')).rejects.toThrow(
+        'Client error (400): Bad request'
+      );
+    });
+
+    test('should timeout after max attempts', async () => {
+      nock('https://test-api.com')
+        .get('/prediction')
+        .query({ request_id: 'req-123' })
+        .times(3)
+        .reply(202); // Always processing
+
+      const client = new ValenceClient();
+      await expect(client.asynch.emotions('req-123', 3, 100)).rejects.toThrow(
+        'Prediction not available after 3 attempts. The request may still be processing.'
+      );
+    });
+
+    test('should handle server errors gracefully', async () => {
+      nock('https://test-api.com')
+        .get('/prediction')
+        .query({ request_id: 'req-123' })
+        .reply(500)
+        .get('/prediction')
+        .query({ request_id: 'req-123' })
+        .reply(200, { emotions: { happy: 1.0 } });
+
+      const client = new ValenceClient();
+      const result = await client.asynch.emotions('req-123', 5, 100);
+      
+      expect(result).toEqual({ emotions: { happy: 1.0 } });
+    });
+
+    test('should include correct headers', async () => {
+      const scope = nock('https://test-api.com')
+        .get('/prediction')
+        .matchHeader('x-api-key', 'test-api-key')
+        .matchHeader('User-Agent', 'valenceai/0.4.0')
+        .query({ request_id: 'req-123' })
+        .reply(200, { emotions: {} });
+
+      const client = new ValenceClient();
+      await client.asynch.emotions('req-123');
+      
+      expect(scope.isDone()).toBe(true);
+    });
+  });
+});

package/tests/client.test.js

@@ -0,0 +1,42 @@
+import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { getHeaders } from '../src/client.js';
+
+describe('Client', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe('getHeaders', () => {
+    test('should return headers with API key', async () => {
+      process.env.VALENCE_API_KEY = 'test-api-key';
+      
+      // Re-import to get fresh config
+      const { getHeaders: freshGetHeaders } = await import('../src/client.js?' + Math.random());
+      
+      const headers = freshGetHeaders();
+      
+      expect(headers).toEqual({
+        'x-api-key': 'test-api-key',
+        'User-Agent': 'valenceai/0.4.0'
+      });
+    });
+
+    test('should throw error when API key is missing', () => {
+      delete process.env.VALENCE_API_KEY;
+      
+      expect(() => getHeaders()).toThrow('VALENCE_API_KEY is required but not configured');
+    });
+
+    test('should throw error when API key is empty string', () => {
+      process.env.VALENCE_API_KEY = '';
+      
+      expect(() => getHeaders()).toThrow('VALENCE_API_KEY is required but not configured');
+    });
+  });
+});

package/tests/config.test.js

@@ -0,0 +1,90 @@
+import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { config, validateConfig } from '../src/config.js';
+
+describe('Config', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe('config object', () => {
+    test('should load from environment variables', async () => {
+      process.env.VALENCE_API_KEY = 'test-key';
+      process.env.VALENCE_DISCRETE_URL = 'https://test-short.com';
+      process.env.VALENCE_ASYNC_URL = 'https://test-long.com';
+      process.env.VALENCE_LOG_LEVEL = 'debug';
+
+      // Re-import to get fresh config
+      const { config: freshConfig } = await import('../src/config.js?' + Math.random());
+
+      expect(freshConfig.apiKey).toBe('test-key');
+      expect(freshConfig.discreteAudioUrl).toBe('https://test-short.com');
+      expect(freshConfig.asyncAudioUrl).toBe('https://test-long.com');
+      expect(freshConfig.logLevel).toBe('debug');
+    });
+
+    test('should use default URLs when not provided', async () => {
+      process.env.VALENCE_API_KEY = 'test-key';
+      delete process.env.VALENCE_DISCRETE_URL;
+      delete process.env.VALENCE_ASYNC_URL;
+
+      // Re-import to get fresh config
+      const { config: freshConfig } = await import('../src/config.js?' + Math.random());
+
+      expect(freshConfig.discreteAudioUrl).toBe('https://xc8n2bo4f0.execute-api.us-west-2.amazonaws.com/emotionprediction');
+      expect(freshConfig.asyncAudioUrl).toBe('https://wsgol61783.execute-api.us-west-2.amazonaws.com/prod');
+    });
+
+    test('should use default log level when not provided', async () => {
+      delete process.env.VALENCE_LOG_LEVEL;
+      
+      // Re-import to get fresh config
+      const { config: freshConfig } = await import('../src/config.js?' + Math.random());
+      
+      expect(freshConfig.logLevel).toBe('info');
+    });
+  });
+
+  describe('validateConfig', () => {
+    test('should pass with valid configuration', () => {
+      process.env.VALENCE_API_KEY = 'test-key';
+      process.env.VALENCE_DISCRETE_URL = 'https://test-short.com';
+      process.env.VALENCE_ASYNC_URL = 'https://test-long.com';
+      process.env.VALENCE_LOG_LEVEL = 'info';
+
+      expect(() => validateConfig()).not.toThrow();
+    });
+
+    test('should throw when API key is missing', async () => {
+      delete process.env.VALENCE_API_KEY;
+      const { validateConfig: freshValidateConfig } = await import('../src/config.js?' + Math.random());
+      expect(() => freshValidateConfig()).toThrow('VALENCE_API_KEY environment variable is required');
+    });
+
+    test('should throw when short URL is not HTTPS', async () => {
+      process.env.VALENCE_API_KEY = 'test-key';
+      process.env.VALENCE_DISCRETE_URL = 'http://test-short.com';
+      const { validateConfig: freshValidateConfig } = await import('../src/config.js?' + Math.random());
+      expect(() => freshValidateConfig()).toThrow('VALENCE_DISCRETE_URL must be a valid HTTPS URL');
+    });
+
+    test('should throw when long URL is not HTTPS', async () => {
+      process.env.VALENCE_API_KEY = 'test-key';
+      process.env.VALENCE_ASYNC_URL = 'http://test-long.com';
+      const { validateConfig: freshValidateConfig } = await import('../src/config.js?' + Math.random());
+      expect(() => freshValidateConfig()).toThrow('VALENCE_ASYNC_URL must be a valid HTTPS URL');
+    });
+
+    test('should throw with invalid log level', async () => {
+      process.env.VALENCE_API_KEY = 'test-key';
+      process.env.VALENCE_LOG_LEVEL = 'invalid';
+      const { validateConfig: freshValidateConfig } = await import('../src/config.js?' + Math.random());
+      expect(() => freshValidateConfig()).toThrow('VALENCE_LOG_LEVEL must be one of: debug, info, warn, error');
+    });
+  });
+});

package/tests/discreteAudio.test.js

@@ -0,0 +1,168 @@
+import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
+import nock from 'nock';
+import fs from 'fs';
+import { ValenceClient } from '../src/valenceClient.js';
+
+describe('DiscreteAudio', () => {
+  const originalEnv = process.env;
+  let fsMock;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+    process.env.VALENCE_API_KEY = 'test-api-key';
+    process.env.VALENCE_DISCRETE_URL = 'https://test-api.com/predict';
+    
+    fsMock = jest.spyOn(fs, 'existsSync');
+    jest.spyOn(fs, 'createReadStream').mockReturnValue({
+      pipe: jest.fn(),
+      on: jest.fn()
+    });
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+    jest.restoreAllMocks();
+    nock.cleanAll();
+  });
+
+  describe('predictDiscreteAudioEmotion', () => {
+    test('should successfully predict emotions', async () => {
+      fsMock.mockReturnValue(true);
+      
+      const mockResponse = {
+        emotions: {
+          happy: 0.8,
+          sad: 0.1,
+          angry: 0.1
+        }
+      };
+
+      nock('https://test-api.com')
+        .post('/predict?model=7emotions')
+        .reply(200, mockResponse);
+
+      const client = new ValenceClient();
+      const result = await client.discrete.emotions('test.wav', '7emotions');
+      
+      expect(result).toEqual(mockResponse);
+    });
+
+    test('should use default model when not specified', async () => {
+      fsMock.mockReturnValue(true);
+      
+      nock('https://test-api.com')
+        .post('/predict?model=4emotions')
+        .reply(200, { emotions: {} });
+
+      const client = new ValenceClient();
+      await client.discrete.emotions('test.wav');
+      
+      expect(nock.isDone()).toBe(true);
+    });
+
+    test('should throw error when filePath is missing', async () => {
+      const client = new ValenceClient();
+      await expect(client.discrete.emotions()).rejects.toThrow(
+        'filePath is required and must be a string'
+      );
+    });
+
+    test('should throw error when filePath is not a string', async () => {
+      const client = new ValenceClient();
+      await expect(client.discrete.emotions(123)).rejects.toThrow(
+        'filePath is required and must be a string'
+      );
+    });
+
+    test('should throw error with invalid model', async () => {
+      const client = new ValenceClient();
+      await expect(client.discrete.emotions('test.wav', 'invalid')).rejects.toThrow(
+        'model must be either "4emotions" or "7emotions"'
+      );
+    });
+
+    test('should throw error when API key is missing', async () => {
+      delete process.env.VALENCE_API_KEY;
+      
+      const client = new ValenceClient();
+      await expect(client.discrete.emotions('test.wav')).rejects.toThrow(
+        'VALENCE_API_KEY is required'
+      );
+    });
+
+    test('should throw error when file does not exist', async () => {
+      fsMock.mockReturnValue(false);
+      
+      const client = new ValenceClient();
+      await expect(client.discrete.emotions('nonexistent.wav')).rejects.toThrow(
+        'File not found: nonexistent.wav'
+      );
+    });
+
+    test('should handle API error responses', async () => {
+      fsMock.mockReturnValue(true);
+      
+      nock('https://test-api.com')
+        .post('/predict?model=4emotions')
+        .reply(400, { message: 'Invalid file format' });
+
+      const client = new ValenceClient();
+      await expect(client.discrete.emotions('test.wav')).rejects.toThrow(
+        'API error (400): Invalid file format'
+      );
+    });
+
+    test('should handle API error without message', async () => {
+      fsMock.mockReturnValue(true);
+      
+      nock('https://test-api.com')
+        .post('/predict?model=4emotions')
+        .reply(500, 'Internal Server Error');
+
+      const client = new ValenceClient();
+      await expect(client.discrete.emotions('test.wav')).rejects.toThrow(
+        'API error (500): Internal Server Error'
+      );
+    });
+
+    test('should handle network errors', async () => {
+      fsMock.mockReturnValue(true);
+      
+      nock('https://test-api.com')
+        .post('/predict?model=4emotions')
+        .replyWithError('Network error');
+
+      const client = new ValenceClient();
+      await expect(client.discrete.emotions('test.wav')).rejects.toThrow(
+        'Network error: Unable to reach the API'
+      );
+    });
+
+    test('should handle timeout errors', async () => {
+      fsMock.mockReturnValue(true);
+      
+      nock('https://test-api.com')
+        .post('/predict?model=4emotions')
+        .delay(31000)
+        .reply(200, {});
+
+      const client = new ValenceClient();
+      await expect(client.discrete.emotions('test.wav')).rejects.toThrow();
+    });
+
+    test('should include correct headers', async () => {
+      fsMock.mockReturnValue(true);
+      
+      const scope = nock('https://test-api.com')
+        .post('/predict?model=4emotions')
+        .matchHeader('x-api-key', 'test-api-key')
+        .matchHeader('User-Agent', 'valenceai/0.4.0')
+        .reply(200, { emotions: {} });
+
+      const client = new ValenceClient();
+      await client.discrete.emotions('test.wav');
+      
+      expect(scope.isDone()).toBe(true);
+    });
+  });
+});

package/tests/index.test.js

@@ -0,0 +1,33 @@
+import { describe, test, expect } from '@jest/globals';
+import { ValenceClient, validateConfig } from '../src/index.js';
+
+describe('Index exports', () => {
+  test('should export ValenceClient', () => {
+    expect(typeof ValenceClient).toBe('function');
+  });
+
+  test('should export validateConfig', () => {
+    expect(typeof validateConfig).toBe('function');
+  });
+
+  test('should export all expected functions', async () => {
+    const index = await import('../src/index.js');
+    const expectedExports = ['ValenceClient', 'validateConfig'];
+    
+    expectedExports.forEach(exportName => {
+      expect(index).toHaveProperty(exportName);
+      expect(typeof index[exportName]).toBe('function');
+    });
+  });
+
+  test('should create ValenceClient with nested APIs', () => {
+    process.env.VALENCE_API_KEY = 'test-key';
+    const client = new ValenceClient();
+    
+    expect(client).toHaveProperty('discrete');
+    expect(client).toHaveProperty('asynch');
+    expect(typeof client.discrete.emotions).toBe('function');
+    expect(typeof client.asynch.upload).toBe('function');
+    expect(typeof client.asynch.emotions).toBe('function');
+  });
+});