valenceai 0.5.1 → 1.0.0

package/tests/e2e.asyncWorkflow.test.js

@@ -0,0 +1,343 @@
+/**
+ * End-to-End Tests for Async API Workflow
+ *
+ * These tests validate the complete async API workflow as documented in the README:
+ * 1. Upload Phase - File upload to S3
+ * 2. Background Processing - Server-side processing
+ * 3. Results Retrieval - Polling until completion
+ *
+ * Note: These tests make REAL API calls to the demo server with REAL audio files.
+ * Set VALENCE_E2E_TEST=true and VALENCE_API_KEY to run these tests.
+ */
+
+import { ValenceClient } from '../src/index.js';
+import { describe, test, expect, beforeAll } from '@jest/globals';
+import fs from 'fs';
+import path from 'path';
+import axios from 'axios';
+
+// Skip E2E tests unless explicitly enabled
+const describeE2E = process.env.VALENCE_E2E_TEST === 'true' ? describe : describe.skip;
+
+// Path to real test audio files
+const TEST_AUDIO_DIR = '/Users/julianolarte/code/valenceai/valence-backend-api/tests/fixtures';
+const TEST_SHORT_AUDIO = path.join(TEST_AUDIO_DIR, 'test_file.wav');
+const TEST_LONG_AUDIO = path.join(TEST_AUDIO_DIR, 'long_file_sample.wav');
+
+describeE2E('Async API E2E Tests', () => {
+  let client;
+  let apiKey;
+  let baseUrl;
+
+  beforeAll(() => {
+    // Check for API key
+    apiKey = process.env.VALENCE_API_KEY;
+    if (!apiKey) {
+      throw new Error('VALENCE_API_KEY not set');
+    }
+
+    // Use demo base URL by default
+    baseUrl = process.env.VALENCE_API_BASE_URL || 'https://demo.getvalenceai.com';
+
+    client = new ValenceClient({
+      apiKey,
+      baseUrl
+    });
+
+    // Verify test files exist
+    if (!fs.existsSync(TEST_SHORT_AUDIO)) {
+      throw new Error(`Test audio file not found: ${TEST_SHORT_AUDIO}`);
+    }
+    if (!fs.existsSync(TEST_LONG_AUDIO)) {
+      throw new Error(`Test audio file not found: ${TEST_LONG_AUDIO}`);
+    }
+  });
+
+  test('Complete async workflow with real audio file', async () => {
+    console.log('\n' + '='.repeat(70));
+    console.log('Testing Complete Async Workflow');
+    console.log('='.repeat(70));
+
+    // STEP 1: Upload Phase - File is uploaded to S3
+    console.log('\nSTEP 1: Upload Phase - File upload to S3');
+    console.log('-'.repeat(70));
+    console.log(`Using test file: ${path.basename(TEST_LONG_AUDIO)}`);
+
+    const startUpload = Date.now();
+    const requestId = await client.asynch.upload(TEST_LONG_AUDIO);
+    const uploadTime = (Date.now() - startUpload) / 1000;
+
+    console.log('✓ Upload to S3 complete!');
+    console.log(`  Request ID: ${requestId}`);
+    console.log(`  Upload duration: ${uploadTime.toFixed(2)} seconds`);
+    console.log('  Note: File is uploaded but NOT processed yet');
+
+    // Verify request_id is returned (tracking ID, NOT completion)
+    expect(requestId).toBeDefined();
+    expect(typeof requestId).toBe('string');
+    expect(requestId.length).toBeGreaterThan(0);
+
+    // STEP 2: Background Processing
+    console.log('\nSTEP 2: Background Processing Phase');
+    console.log('-'.repeat(70));
+    console.log('  Server automatically:');
+    console.log('  - Detects uploaded file (checks every 10 seconds)');
+    console.log('  - Downloads audio from S3');
+    console.log('  - Splits into 5-second segments');
+    console.log('  - Runs ML model on each chunk');
+    console.log('  - Stores results in database');
+    console.log('  Status progression: initiated → upload_completed → processing → completed');
+
+    // STEP 3: Poll for Results
+    console.log('\nSTEP 3: Results Retrieval Phase - Polling for completion');
+    console.log('-'.repeat(70));
+
+    const startPoll = Date.now();
+    const result = await client.asynch.emotions(
+      requestId,
+      50,     // maxTries
+      10000   // intervalMs (10 seconds)
+    );
+    const pollTime = (Date.now() - startPoll) / 1000;
+
+    console.log('✓ Processing complete!');
+    console.log(`  Status: ${result.status}`);
+    console.log(`  Processing duration: ${pollTime.toFixed(2)} seconds`);
+    console.log(`  Total emotion data points: ${result.emotions.length}`);
+
+    // Verify results
+    expect(result.status).toBe('completed');
+    expect(result.emotions).toBeDefined();
+    expect(result.emotions.length).toBeGreaterThan(0);
+
+    // Verify emotion data structure
+    const firstEmotion = result.emotions[0];
+    expect(firstEmotion).toHaveProperty('timestamp');
+    expect(firstEmotion).toHaveProperty('start_time');
+    expect(firstEmotion).toHaveProperty('end_time');
+    expect(firstEmotion).toHaveProperty('emotion');
+    expect(firstEmotion).toHaveProperty('confidence');
+
+    console.log('\n  Sample emotion data:');
+    result.emotions.slice(0, 3).forEach((emotion, i) => {
+      console.log(`    [${i+1}] ${emotion.start_time.toFixed(1)}s-${emotion.end_time.toFixed(1)}s: ` +
+                  `${emotion.emotion} (${(emotion.confidence * 100).toFixed(1)}%)`);
+    });
+
+    console.log('\n' + '='.repeat(70));
+    console.log('✅ COMPLETE WORKFLOW TEST PASSED');
+    console.log(`   Total time: ${(uploadTime + pollTime).toFixed(2)} seconds`);
+    console.log('='.repeat(70));
+  }, 600000); // 10 minute timeout for E2E test
+
+  test('Timeline analysis methods', async () => {
+    console.log('\n' + '='.repeat(70));
+    console.log('Testing Timeline Analysis Methods');
+    console.log('='.repeat(70));
+
+    // Upload and wait for processing
+    console.log(`\nUploading: ${path.basename(TEST_LONG_AUDIO)}`);
+    const requestId = await client.asynch.upload(TEST_LONG_AUDIO);
+    console.log(`Request ID: ${requestId}`);
+
+    console.log('\nWaiting for processing...');
+    const result = await client.asynch.emotions(requestId, 50, 10000);
+    expect(result.status).toBe('completed');
+    console.log('✓ Processing complete');
+
+    // Test getTimeline()
+    console.log('\n1. Testing getTimeline()');
+    console.log('-'.repeat(70));
+    const timeline = await client.asynch.getTimeline(requestId);
+
+    expect(timeline).toBeDefined();
+    expect(timeline.length).toBeGreaterThan(0);
+    expect(timeline.every(point => 'emotion' in point)).toBe(true);
+
+    console.log(`✓ Timeline retrieved: ${timeline.length} data points`);
+    console.log(`  First emotion: ${timeline[0].emotion}`);
+    console.log(`  Last emotion: ${timeline[timeline.length - 1].emotion}`);
+
+    // Test getEmotionAtTime()
+    console.log('\n2. Testing getEmotionAtTime()');
+    console.log('-'.repeat(70));
+    const midPoint = timeline[Math.floor(timeline.length / 2)];
+    const midTime = midPoint.timestamp;
+
+    const emotionAtTime = await client.asynch.getEmotionAtTime(requestId, midTime);
+
+    expect(emotionAtTime).toBeDefined();
+    expect(emotionAtTime).toHaveProperty('emotion');
+
+    console.log(`✓ Emotion at ${midTime.toFixed(1)}s: ${emotionAtTime.emotion}`);
+    console.log(`  Confidence: ${emotionAtTime.confidence ? (emotionAtTime.confidence * 100).toFixed(1) + '%' : 'N/A'}`);
+
+    // Test getDominantEmotion()
+    console.log('\n3. Testing getDominantEmotion()');
+    console.log('-'.repeat(70));
+    const dominant = await client.asynch.getDominantEmotion(requestId);
+
+    expect(dominant).toBeDefined();
+    expect(typeof dominant).toBe('string');
+
+    // Count emotions to verify
+    const emotionCounts = {};
+    timeline.forEach(point => {
+      const emotion = point.emotion;
+      emotionCounts[emotion] = (emotionCounts[emotion] || 0) + 1;
+    });
+
+    console.log(`✓ Dominant emotion: ${dominant}`);
+    console.log('  Emotion distribution:');
+    Object.entries(emotionCounts)
+      .sort(([, a], [, b]) => b - a)
+      .forEach(([emotion, count]) => {
+        const percentage = (count / timeline.length) * 100;
+        console.log(`    ${emotion}: ${count} (${percentage.toFixed(1)}%)`);
+      });
+
+    console.log('\n' + '='.repeat(70));
+    console.log('✅ TIMELINE METHODS TEST PASSED');
+    console.log('='.repeat(70));
+  }, 600000);
+
+  test('Status progression during processing', async () => {
+    console.log('\n' + '='.repeat(70));
+    console.log('Testing Status Progression');
+    console.log('='.repeat(70));
+
+    // Upload
+    console.log(`\nUploading: ${path.basename(TEST_LONG_AUDIO)}`);
+    const requestId = await client.asynch.upload(TEST_LONG_AUDIO);
+    console.log(`✓ Upload complete. Request ID: ${requestId}`);
+
+    // Poll with small intervals to catch status changes
+    console.log('\nPolling status with 5-second intervals...');
+    console.log('Expected progression: initiated → upload_completed → processing → completed');
+    console.log('-'.repeat(70));
+
+    const statusesSeen = [];
+    const maxChecks = 50;
+
+    for (let i = 0; i < maxChecks; i++) {
+      await new Promise(resolve => setTimeout(resolve, 5000));
+
+      try {
+        const url = `${baseUrl}/v1/asynch/emotion/status/${requestId}`;
+        const response = await axios.get(url, {
+          headers: { 'x-api-key': apiKey }
+        });
+
+        if (response.status === 200) {
+          const status = response.data.status;
+
+          if (status && !statusesSeen.includes(status)) {
+            statusesSeen.push(status);
+            console.log(`  [${String(i * 5).padStart(3)}s] Status changed to: ${status}`);
+          }
+
+          if (status === 'completed') {
+            console.log(`\n✓ Processing completed after ${i * 5} seconds`);
+            break;
+          }
+        }
+      } catch (error) {
+        console.log(`  Warning: Status check error: ${error.message}`);
+      }
+    }
+
+    console.log(`\nStatus progression observed: ${statusesSeen.join(' → ')}`);
+
+    expect(statusesSeen).toContain('completed');
+
+    console.log('\n' + '='.repeat(70));
+    console.log('✅ STATUS PROGRESSION TEST PASSED');
+    console.log('='.repeat(70));
+  }, 600000);
+
+  test('request_id is tracking ID (NOT completion signal)', async () => {
+    console.log('\n' + '='.repeat(70));
+    console.log('Testing: request_id is Tracking ID (NOT Completion Signal)');
+    console.log('='.repeat(70));
+
+    // Measure upload time
+    console.log(`\nUploading: ${path.basename(TEST_LONG_AUDIO)}`);
+    console.log('Measuring time to receive request_id...');
+
+    const startTime = Date.now();
+    const requestId = await client.asynch.upload(TEST_LONG_AUDIO);
+    const uploadDuration = (Date.now() - startTime) / 1000;
+
+    console.log(`\n✓ request_id received: ${requestId}`);
+    console.log(`  Time to get request_id: ${uploadDuration.toFixed(2)} seconds`);
+    console.log('  ⚠️  This is ONLY the S3 upload time');
+
+    // Verify request_id is available quickly
+    expect(requestId).toBeDefined();
+    expect(typeof requestId).toBe('string');
+    expect(uploadDuration).toBeLessThan(60); // Should be relatively quick
+
+    // Now measure actual processing time
+    console.log('\nNow polling for actual processing completion...');
+    console.log('This will take longer because server needs to process audio...');
+
+    const processStart = Date.now();
+    const result = await client.asynch.emotions(requestId, 50, 10000);
+    const processDuration = (Date.now() - processStart) / 1000;
+
+    console.log(`\n✓ Processing complete: ${result.status}`);
+    console.log(`  Time to process: ${processDuration.toFixed(2)} seconds`);
+
+    console.log('\n' + '-'.repeat(70));
+    console.log('PROOF THAT request_id ≠ COMPLETION:');
+    console.log('-'.repeat(70));
+    console.log(`  Upload returned request_id in:  ${uploadDuration.toFixed(2).padStart(6)} seconds`);
+    console.log(`  But processing actually took:    ${processDuration.toFixed(2).padStart(6)} seconds`);
+    console.log(`  Difference:                      ${(processDuration - uploadDuration).toFixed(2).padStart(6)} seconds`);
+    console.log('\n  ✓ Therefore: request_id is a TRACKING ID, not a completion signal');
+
+    // Processing should take longer than just getting request_id
+    expect(processDuration).toBeGreaterThan(uploadDuration);
+
+    console.log('\n' + '='.repeat(70));
+    console.log('✅ TRACKING ID VALIDATION TEST PASSED');
+    console.log('='.repeat(70));
+  }, 600000);
+
+  test('Async workflow with short audio', async () => {
+    console.log('\n' + '='.repeat(70));
+    console.log('Testing Async Workflow with Short Audio');
+    console.log('='.repeat(70));
+
+    console.log(`\nUploading: ${path.basename(TEST_SHORT_AUDIO)}`);
+
+    // Upload
+    const requestId = await client.asynch.upload(TEST_SHORT_AUDIO);
+    console.log(`✓ Request ID: ${requestId}`);
+
+    // Process
+    console.log('\nProcessing...');
+    const result = await client.asynch.emotions(requestId, 30, 10000);
+
+    console.log(`✓ Status: ${result.status}`);
+    console.log(`  Emotion data points: ${result.emotions.length}`);
+
+    expect(result.status).toBe('completed');
+    expect(result.emotions.length).toBeGreaterThan(0);
+
+    console.log('\n' + '='.repeat(70));
+    console.log('✅ SHORT AUDIO TEST PASSED');
+    console.log('='.repeat(70));
+  }, 600000);
+});
+
+if (process.env.VALENCE_E2E_TEST !== 'true') {
+  console.log('\n' + '='.repeat(70));
+  console.log('Valence SDK - Async API E2E Tests');
+  console.log('='.repeat(70));
+  console.log('\nTo run these tests:');
+  console.log('  export VALENCE_E2E_TEST=true');
+  console.log('  export VALENCE_API_KEY=your_api_key');
+  console.log('  npm test -- tests/e2e.asyncWorkflow.test.js');
+  console.log('\n' + '='.repeat(70));
+}