WellNuo/services/ble/__tests__/BLEManager.performance.test.ts

/**
 * BLE Manager Performance Tests
 *
 * Tests for performance optimizations:
 * - Early scan termination when devices found
 * - BLE operations < 10 seconds target
 */

import { BLE_CONFIG } from '../types';

describe('BLE Performance Configuration', () => {
  describe('Scan Timeout Configuration', () => {
    it('should have max scan timeout of 10 seconds', () => {
      expect(BLE_CONFIG.SCAN_TIMEOUT).toBe(10000);
    });

    it('should have early exit timeout of 3 seconds', () => {
      expect(BLE_CONFIG.SCAN_EARLY_EXIT_TIMEOUT).toBe(3000);
    });

    it('should require at least 1 device for early exit', () => {
      expect(BLE_CONFIG.SCAN_MIN_DEVICES_FOR_EARLY_EXIT).toBe(1);
    });

    it('should have command timeout of 5 seconds', () => {
      expect(BLE_CONFIG.COMMAND_TIMEOUT).toBe(5000);
    });
  });

  describe('Performance Targets', () => {
    it('should have scan timeout within 10 second BLE operation target', () => {
      // BLE operations should complete within 10 seconds
      expect(BLE_CONFIG.SCAN_TIMEOUT).toBeLessThanOrEqual(10000);
    });

    it('should have early exit timeout significantly faster than max timeout', () => {
      // Early exit should be at least 2x faster than max timeout
      expect(BLE_CONFIG.SCAN_EARLY_EXIT_TIMEOUT).toBeLessThanOrEqual(
        BLE_CONFIG.SCAN_TIMEOUT / 2
      );
    });

    it('should have command timeout allow for multiple commands within target', () => {
      // Should be able to send at least 2 commands within 10 second target
      expect(BLE_CONFIG.COMMAND_TIMEOUT * 2).toBeLessThanOrEqual(10000);
    });
  });
});

describe('BLE Scan Early Exit Logic', () => {
  it('should trigger early exit after minimum devices found + early exit timeout', () => {
    // This tests the logic of early termination:
    // 1. Scan starts
    // 2. First device found (meets SCAN_MIN_DEVICES_FOR_EARLY_EXIT)
    // 3. Early exit timer starts (SCAN_EARLY_EXIT_TIMEOUT = 3s)
    // 4. After 3s, scan completes (instead of waiting full 10s)

    const minDevices = BLE_CONFIG.SCAN_MIN_DEVICES_FOR_EARLY_EXIT;
    const earlyExitTime = BLE_CONFIG.SCAN_EARLY_EXIT_TIMEOUT;
    const maxTime = BLE_CONFIG.SCAN_TIMEOUT;

    // Verify early exit is beneficial
    expect(minDevices + earlyExitTime).toBeLessThan(maxTime);

    // Best case: find device immediately, exit after 3s
    const bestCaseTime = earlyExitTime;
    expect(bestCaseTime).toBe(3000);

    // Worst case: no devices found, exit after 10s
    const worstCaseTime = maxTime;
    expect(worstCaseTime).toBe(10000);
  });

  it('should respect device name prefix filter', () => {
    expect(BLE_CONFIG.DEVICE_NAME_PREFIX).toBe('WP_');
  });
});

describe('BLE WiFi Configuration Performance', () => {
  it('should have reasonable timeouts for WiFi setup sequence', () => {
    // WiFi setup sequence:
    // 1. Connect to device (10s timeout)
    // 2. Unlock with PIN (5s command timeout)
    // 3. Send WiFi credentials (5s command timeout)
    // 4. Reboot device (5s command timeout)

    const connectTimeout = 10000; // From connectToDevice options
    const commandTimeout = BLE_CONFIG.COMMAND_TIMEOUT;

    // Total time for single device WiFi setup
    const singleDeviceMaxTime = connectTimeout + commandTimeout * 3;

    // Should complete single device within 10 second target (with some buffer)
    // Note: actual target allows up to 10s for BLE operations
    expect(singleDeviceMaxTime).toBeLessThanOrEqual(25000);

    // But typical case is much faster (1-2s connect + 0.5s per command)
    const typicalTime = 2000 + 500 * 3;
    expect(typicalTime).toBeLessThan(10000);
  });
});

describe('BLE Bulk Operations Performance', () => {
  it('should handle bulk WiFi config for multiple devices', () => {
    // For bulk operations, devices are processed sequentially
    // Each device: connect (2s typical) + commands (1.5s typical) = 3.5s

    const typicalDeviceTime = 3500;
    const numDevices = 3;

    const totalTime = typicalDeviceTime * numDevices;

    // 3 devices should complete in about 10.5 seconds
    // This is slightly over the 10s target, which is acceptable for bulk ops
    expect(totalTime).toBeLessThan(15000);
  });
});