facecog-liveness-showcase 0.0.1

package/projects/facecog-liveness-verification/src/lib/services/custom-poses-api.service.ts

@@ -0,0 +1,117 @@
+import { Injectable, Inject, Optional } from '@angular/core';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { tap } from 'rxjs/operators';
+import { ICustomPoseRepository } from '../interfaces/custom-pose-repository.interface';
+import { CustomPoseData } from '../interfaces/custom-pose-data.interface';
+import { CustomPoseResponse } from '../interfaces/custom-pose-response.interface';
+import { LIVENESS_VERIFICATION_CONFIG } from '../models/constants/liveness-verification-config.token';
+import type { LivenessVerificationConfig } from '../interfaces/liveness-verification-config.interface';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CustomPosesApiService implements ICustomPoseRepository {
+  private readonly baseUrl: string;
+  private readonly endpoint = '/api/custom-poses';
+  private customPosesSubject = new BehaviorSubject<CustomPoseData[]>([]);
+  public customPoses$ = this.customPosesSubject.asObservable();
+
+  constructor(
+    private http: HttpClient,
+    @Optional() @Inject(LIVENESS_VERIFICATION_CONFIG) config?: LivenessVerificationConfig | null
+  ) {
+    this.baseUrl = config?.apiUrl || 'http://localhost:3002';
+  }
+
+  private getHeaders(): HttpHeaders {
+    return new HttpHeaders({ 'x-user-id': 'default-user' });
+  }
+
+  loadCustomPoses(): Observable<CustomPoseResponse> {
+    return this.http.get<CustomPoseResponse>(`${this.baseUrl}${this.endpoint}`, { headers: this.getHeaders() }).pipe(
+      tap(response => {
+        if (response.success && response.poses) {
+          this.customPosesSubject.next(response.poses);
+        }
+      })
+    );
+  }
+
+  createCustomPose(
+    name: string,
+    description: string,
+    category: string,
+    difficulty: string,
+    imageFile: File,
+    poseKeypoints: unknown
+  ): Observable<CustomPoseResponse> {
+    const formData = new FormData();
+    formData.append('image', imageFile);
+    formData.append('name', name);
+    formData.append('description', description);
+    formData.append('category', category);
+    formData.append('difficulty', difficulty);
+    formData.append('poseKeypoints', JSON.stringify(poseKeypoints));
+
+    return this.http.post<CustomPoseResponse>(`${this.baseUrl}${this.endpoint}`, formData, { headers: this.getHeaders() }).pipe(
+      tap(response => { if (response.success) this.loadCustomPoses().subscribe(); })
+    );
+  }
+
+  async createCustomPoseFromBase64(
+    name: string,
+    description: string,
+    category: string,
+    difficulty: string,
+    base64Image: string,
+    poseKeypoints: unknown
+  ): Promise<{ pose: CustomPoseData; isNew: boolean }> {
+    const imageFile = await this.base64ToFile(base64Image, `${name.replace(/\s+/g, '-')}.png`);
+    return new Promise((resolve, reject) => {
+      this.createCustomPose(name, description, category, difficulty, imageFile, poseKeypoints).subscribe({
+        next: (r) => {
+          if (r.success && r.pose) {
+            // isNew is returned by backend, defaults to true for backwards compatibility
+            resolve({ pose: r.pose, isNew: r.isNew !== false });
+          } else {
+            reject(new Error(r.error || 'Failed to create custom pose'));
+          }
+        },
+        error: reject
+      });
+    });
+  }
+
+  getCustomPoseById(id: number): Observable<CustomPoseResponse> {
+    return this.http.get<CustomPoseResponse>(`${this.baseUrl}${this.endpoint}/${id}`, { headers: this.getHeaders() });
+  }
+
+  updateCustomPose(id: number, updates: Partial<CustomPoseData>): Observable<CustomPoseResponse> {
+    return this.http.put<CustomPoseResponse>(`${this.baseUrl}${this.endpoint}/${id}`, updates, { headers: this.getHeaders() }).pipe(
+      tap(r => { if (r.success) this.loadCustomPoses().subscribe(); })
+    );
+  }
+
+  deleteCustomPose(id: number): Observable<CustomPoseResponse> {
+    return this.http.delete<CustomPoseResponse>(`${this.baseUrl}${this.endpoint}/${id}`, { headers: this.getHeaders() }).pipe(
+      tap(r => { if (r.success) this.loadCustomPoses().subscribe(); })
+    );
+  }
+
+  deleteAllCustomPoses(): Observable<CustomPoseResponse> {
+    return this.http.delete<CustomPoseResponse>(`${this.baseUrl}${this.endpoint}?confirm=true`, { headers: this.getHeaders() }).pipe(
+      tap(r => { if (r.success) this.customPosesSubject.next([]); })
+    );
+  }
+
+  getCustomPoses(): CustomPoseData[] {
+    return this.customPosesSubject.value;
+  }
+
+  private async base64ToFile(base64: string, filename: string): Promise<File> {
+    const response = await fetch(base64);
+    const blob = await response.blob();
+    return new File([blob], filename, { type: 'image/png' });
+  }
+}

package/projects/facecog-liveness-verification/src/lib/services/index.ts

@@ -0,0 +1,18 @@
+/**
+ * Services barrel export
+ */
+export * from './camera.service';
+export * from './liveness-config.service';
+export * from './video-recorder.service';
+export * from './pose-selection.service';
+export * from '../interfaces/backend-adapter.interface';
+export * from './backends/mock-backend.service';
+
+// Showcase/moved services
+export * from './backend-http.service';
+export * from './custom-poses-api.service';
+export * from './verification-plan.service';
+export * from './verification-api.service';
+export * from './aws-face-liveness.service';
+export * from './liveness-backend.service';
+

package/projects/facecog-liveness-verification/src/lib/services/liveness-backend.service.spec.ts

@@ -0,0 +1,103 @@
+import { TestBed } from '@angular/core/testing';
+import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing';
+import { LivenessBackendService } from './liveness-backend.service';
+import { LIVENESS_VERIFICATION_CONFIG } from '../models/constants/liveness-verification-config.token';
+
+describe('LivenessBackendService', () => {
+  let service: LivenessBackendService;
+  let httpMock: HttpTestingController;
+
+  describe('without config', () => {
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        imports: [HttpClientTestingModule],
+        providers: [LivenessBackendService]
+      });
+      service = TestBed.inject(LivenessBackendService);
+      httpMock = TestBed.inject(HttpTestingController);
+    });
+
+    afterEach(() => httpMock.verify());
+
+    it('should be created', () => {
+      expect(service).toBeTruthy();
+    });
+
+    it('createSession sends POST', () => {
+      service.createSession('amazon').subscribe(res => expect(res).toBeDefined());
+      const req = httpMock.expectOne('http://localhost:3002/liveness/session/create');
+      expect(req.request.method).toBe('POST');
+      expect(req.request.body).toEqual({ backend: 'amazon', referenceImage: undefined });
+      req.flush({ sessionId: 's1' });
+    });
+
+    it('createSession with referenceImage', () => {
+      service.createSession('openpose', 'img').subscribe();
+      const req = httpMock.expectOne('http://localhost:3002/liveness/session/create');
+      expect(req.request.body.referenceImage).toBe('img');
+      req.flush({ sessionId: 's1' });
+    });
+
+    it('analyzeLiveness sends POST', () => {
+      service.analyzeLiveness('s1', 'amazon', 'video', ['f1']).subscribe();
+      const req = httpMock.expectOne('http://localhost:3002/liveness/analyze');
+      expect(req.request.body).toEqual({ sessionId: 's1', backend: 'amazon', videoBase64: 'video', frames: ['f1'] });
+      req.flush({ isLive: true, confidence: 0.9 });
+    });
+
+    it('analyzeWithAllThreeBackends sends POST', () => {
+      service.analyzeWithAllThreeBackends('s1', 'video', ['f1']).subscribe();
+      const req = httpMock.expectOne('http://localhost:3002/liveness/analyze-all');
+      expect(req.request.body).toEqual({ sessionId: 's1', videoBase64: 'video', frames: ['f1'] });
+      req.flush({});
+    });
+
+    it('verifyPose sends POST', () => {
+      service.verifyPose('s1', 'frame', 'ref').subscribe();
+      const req = httpMock.expectOne('http://localhost:3002/liveness/verify-pose');
+      expect(req.request.body).toEqual({ sessionId: 's1', frame: 'frame', referenceImage: 'ref' });
+      req.flush({ matched: true });
+    });
+
+    it('getSession sends GET', () => {
+      service.getSession('s1').subscribe();
+      const req = httpMock.expectOne('http://localhost:3002/liveness/session/s1');
+      expect(req.request.method).toBe('GET');
+      req.flush({});
+    });
+
+    it('deleteSession sends DELETE', () => {
+      service.deleteSession('s1').subscribe();
+      const req = httpMock.expectOne('http://localhost:3002/liveness/session/s1');
+      expect(req.request.method).toBe('DELETE');
+      req.flush({});
+    });
+
+    it('setApiUrl changes the base URL', () => {
+      service.setApiUrl('https://custom.api/liveness');
+      service.getSession('s1').subscribe();
+      httpMock.expectOne('https://custom.api/liveness/session/s1');
+    });
+  });
+
+  describe('with config', () => {
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        imports: [HttpClientTestingModule],
+        providers: [
+          LivenessBackendService,
+          { provide: LIVENESS_VERIFICATION_CONFIG, useValue: { apiUrl: 'https://prod.api' } }
+        ]
+      });
+      service = TestBed.inject(LivenessBackendService);
+      httpMock = TestBed.inject(HttpTestingController);
+    });
+
+    afterEach(() => httpMock.verify());
+
+    it('uses configured apiUrl', () => {
+      service.getSession('s1').subscribe();
+      httpMock.expectOne('https://prod.api/liveness/session/s1');
+    });
+  });
+});

package/projects/facecog-liveness-verification/src/lib/services/liveness-backend.service.ts

@@ -0,0 +1,61 @@
+import { Injectable, Inject, Optional } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { LivenessBackend } from '../types/liveness-backend.type';
+import { SessionResponse } from '../interfaces/backend-http-client.interface';
+import { AnalyzeResponse } from '../interfaces/analyze-response.interface';
+import { PoseVerifyResponse } from '../interfaces/pose-verify-response.interface';
+import { LIVENESS_VERIFICATION_CONFIG } from '../models/constants/liveness-verification-config.token';
+import type { LivenessVerificationConfig } from '../interfaces/liveness-verification-config.interface';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class LivenessBackendService {
+  private apiUrl: string;
+
+  constructor(
+    private http: HttpClient,
+    @Optional() @Inject(LIVENESS_VERIFICATION_CONFIG) config?: LivenessVerificationConfig | null
+  ) {
+    const base = config?.apiUrl || 'http://localhost:3002';
+    this.apiUrl = `${base}/liveness`;
+  }
+
+  setApiUrl(url: string): void {
+    this.apiUrl = url;
+  }
+
+  createSession(backend: LivenessBackend, referenceImage?: string): Observable<SessionResponse> {
+    return this.http.post<SessionResponse>(`${this.apiUrl}/session/create`, { backend, referenceImage });
+  }
+
+  analyzeLiveness(
+    sessionId: string,
+    backend: LivenessBackend,
+    videoBase64?: string,
+    frames?: string[]
+  ): Observable<AnalyzeResponse> {
+    return this.http.post<AnalyzeResponse>(`${this.apiUrl}/analyze`, { sessionId, backend, videoBase64, frames });
+  }
+
+  analyzeWithAllThreeBackends(
+    sessionId: string,
+    videoBase64?: string,
+    frames?: string[]
+  ): Observable<unknown> {
+    return this.http.post(`${this.apiUrl}/analyze-all`, { sessionId, videoBase64, frames });
+  }
+
+  verifyPose(sessionId: string, frame: string, referenceImage: string): Observable<PoseVerifyResponse> {
+    return this.http.post<PoseVerifyResponse>(`${this.apiUrl}/verify-pose`, { sessionId, frame, referenceImage });
+  }
+
+  getSession(sessionId: string): Observable<unknown> {
+    return this.http.get(`${this.apiUrl}/session/${sessionId}`);
+  }
+
+  deleteSession(sessionId: string): Observable<unknown> {
+    return this.http.delete(`${this.apiUrl}/session/${sessionId}`);
+  }
+}

package/projects/facecog-liveness-verification/src/lib/services/liveness-config.service.spec.ts

@@ -0,0 +1,109 @@
+import { TestBed } from '@angular/core/testing';
+
+import { LivenessConfigService } from './liveness-config.service';
+import { LIVENESS_VERIFICATION_CONFIG } from '../models/constants/liveness-verification-config.token';
+import { DEFAULT_LIVENESS_CONFIG } from '../models/constants/default-liveness-config.constant';
+import type { LivenessVerificationConfig } from '../interfaces/liveness-verification-config.interface';
+import type { LivenessBackend } from '../types/liveness-backend.type';
+
+describe('LivenessConfigService', () => {
+  let service: LivenessConfigService;
+
+  describe('without injection token', () => {
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        providers: [LivenessConfigService]
+      });
+      service = TestBed.inject(LivenessConfigService);
+    });
+
+    it('creates with default config when no injection token', () => {
+      const config = service.getConfig();
+      expect(config).toBeDefined();
+      expect(config.apiUrl).toBe(DEFAULT_LIVENESS_CONFIG.apiUrl);
+      expect(config.backends).toEqual(DEFAULT_LIVENESS_CONFIG.backends);
+      expect(config.maxRetries).toBe(DEFAULT_LIVENESS_CONFIG.maxRetries);
+    });
+
+    it('getConfig returns current config', () => {
+      const config = service.getConfig();
+      expect(config).toEqual(jasmine.objectContaining({
+        apiUrl: 'http://localhost:3002',
+        backends: ['mock'],
+        maxRetries: 3
+      }));
+    });
+
+    it('updateConfig merges partial config', () => {
+      service.updateConfig({ maxRetries: 5, apiUrl: 'https://custom.api' });
+      const config = service.getConfig();
+      expect(config.maxRetries).toBe(5);
+      expect(config.apiUrl).toBe('https://custom.api');
+    });
+
+    it('setCustomPose sets customPose in config', () => {
+      const customPose = { imageData: 'base64data', description: 'Custom pose' };
+      service.setCustomPose(customPose);
+      const config = service.getConfig();
+      expect(config.customPose).toEqual(customPose);
+    });
+
+    it('setPoseId sets poseId in config', () => {
+      service.setPoseId(42);
+      const config = service.getConfig();
+      expect(config.poseId).toBe(42);
+    });
+
+    it('resetConfig resets to defaults', () => {
+      service.updateConfig({ maxRetries: 99, apiUrl: 'https://changed' });
+      service.resetConfig();
+      const config = service.getConfig();
+      expect(config.maxRetries).toBe(DEFAULT_LIVENESS_CONFIG.maxRetries);
+      expect(config.apiUrl).toBe(DEFAULT_LIVENESS_CONFIG.apiUrl);
+    });
+
+    it('enableBackends updates backends', () => {
+      service.enableBackends(['amazon', 'facetec'] as LivenessBackend[]);
+      const config = service.getConfig();
+      expect(config.backends).toEqual(['amazon', 'facetec']);
+    });
+
+    it('config$ observable emits on changes', (done) => {
+      const emissions: LivenessVerificationConfig[] = [];
+      service.config$.subscribe((config) => {
+        emissions.push(config);
+        if (emissions.length >= 2) {
+          expect(emissions[1].maxRetries).toBe(7);
+          done();
+        }
+      });
+
+      service.updateConfig({ maxRetries: 7 });
+    });
+  });
+
+  describe('with injection token', () => {
+    const injectedConfig: Partial<LivenessVerificationConfig> = {
+      apiUrl: 'https://injected.api',
+      maxRetries: 10,
+      backends: ['amazon'] as LivenessBackend[]
+    };
+
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        providers: [
+          LivenessConfigService,
+          { provide: LIVENESS_VERIFICATION_CONFIG, useValue: injectedConfig }
+        ]
+      });
+      service = TestBed.inject(LivenessConfigService);
+    });
+
+    it('creates with merged config when injection token provided', () => {
+      const config = service.getConfig();
+      expect(config.apiUrl).toBe('https://injected.api');
+      expect(config.maxRetries).toBe(10);
+      expect(config.backends).toEqual(['amazon']);
+    });
+  });
+});

package/projects/facecog-liveness-verification/src/lib/services/liveness-config.service.ts

@@ -0,0 +1,70 @@
+import { Injectable, inject } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { LivenessVerificationConfig } from '../interfaces/liveness-verification-config.interface';
+import { LivenessConfig } from '../interfaces/liveness-config.interface';
+import { LivenessBackend } from '../types/liveness-backend.type';
+import { DEFAULT_LIVENESS_CONFIG } from '../models/constants/default-liveness-config.constant';
+import { LIVENESS_VERIFICATION_CONFIG } from '../models/constants/liveness-verification-config.token';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class LivenessConfigService {
+  private configSubject: BehaviorSubject<LivenessVerificationConfig>;
+  public config$: Observable<LivenessVerificationConfig>;
+
+  private injectedConfig = inject(LIVENESS_VERIFICATION_CONFIG, { optional: true });
+
+  constructor() {
+    const initialConfig = { ...DEFAULT_LIVENESS_CONFIG, ...this.injectedConfig };
+    this.configSubject = new BehaviorSubject<LivenessVerificationConfig>(initialConfig);
+    this.config$ = this.configSubject.asObservable();
+  }
+
+  enableBackends(backends: LivenessBackend[]): void {
+    const currentConfig = this.configSubject.value;
+    this.configSubject.next({
+      ...currentConfig,
+      backends
+    });
+  }
+
+  updateConfig(config: Partial<LivenessVerificationConfig>): void {
+    const currentConfig = this.configSubject.value;
+    this.configSubject.next({
+      ...currentConfig,
+      ...config
+    });
+  }
+
+  getConfig(): LivenessVerificationConfig {
+    return this.configSubject.value;
+  }
+
+  getLegacyConfig(): LivenessConfig {
+    const config = this.configSubject.value;
+    return {
+      exampleImageUrl: config.exampleImageUrl,
+      exampleImageBase64: config.exampleImageBase64,
+      backends: config.backends || ['mock'],
+      similarityThreshold: config.similarityThreshold,
+      maxRetries: config.maxRetries,
+      videoMaxSizeMB: config.videoMaxSizeMB,
+      enableVideoRecording: config.enableVideoRecording,
+      enableAutoCapture: config.autoCapture,
+      captureFrameCount: config.captureFrameCount
+    };
+  }
+
+  resetConfig(): void {
+    this.configSubject.next({ ...DEFAULT_LIVENESS_CONFIG });
+  }
+
+  setPoseId(poseId: number): void {
+    this.updateConfig({ poseId });
+  }
+
+  setCustomPose(customPose: { imageData: string; description: string }): void {
+    this.updateConfig({ customPose });
+  }
+}

package/projects/facecog-liveness-verification/src/lib/services/liveness-orchestrator.service.spec.ts

@@ -0,0 +1,144 @@
+import { TestBed } from '@angular/core/testing';
+import { of, throwError } from 'rxjs';
+import { LivenessOrchestratorService } from './liveness-orchestrator.service';
+import { LivenessConfigService } from './liveness-config.service';
+import { MockBackendService } from './backends/mock-backend.service';
+import { RekognitionAnalysisBackendService } from './backends/rekognition-analysis-backend.service';
+import { OpenPoseBackendService } from './backends/openpose-backend.service';
+import { FaceTecBackendService } from './backends/facetec-backend.service';
+import { AzureBackendService } from './backends/azure-backend.service';
+import { BACKEND_HTTP_CLIENT } from '../interfaces/backend-http-client.interface';
+
+describe('LivenessOrchestratorService', () => {
+  let service: LivenessOrchestratorService;
+  let configServiceSpy: any;
+  let mockBackendSpy: any;
+
+  describe('without backend client', () => {
+    beforeEach(() => {
+      configServiceSpy = jasmine.createSpyObj('LivenessConfigService', ['getConfig']);
+      configServiceSpy.getConfig.and.returnValue({ backends: ['mock'] });
+
+      mockBackendSpy = jasmine.createSpyObj('MockBackendService', ['verifyLiveness', 'isAvailable', 'getName']);
+      mockBackendSpy.isAvailable.and.returnValue(true);
+      mockBackendSpy.getName.and.returnValue('mock');
+      mockBackendSpy.verifyLiveness.and.returnValue(of({ isLive: true, confidence: 0.85, details: {} }));
+
+      TestBed.configureTestingModule({
+        providers: [
+          LivenessOrchestratorService,
+          { provide: LivenessConfigService, useValue: configServiceSpy },
+          { provide: MockBackendService, useValue: mockBackendSpy },
+          { provide: RekognitionAnalysisBackendService, useValue: { isAvailable: () => false, getName: () => 'amazon' } },
+          { provide: OpenPoseBackendService, useValue: { isAvailable: () => false, getName: () => 'openpose' } },
+          { provide: FaceTecBackendService, useValue: { isAvailable: () => false, getName: () => 'facetec' } },
+          { provide: AzureBackendService, useValue: { isAvailable: () => false, getName: () => 'azure' } },
+        ]
+      });
+      service = TestBed.inject(LivenessOrchestratorService);
+    });
+
+    it('should be created', () => {
+      expect(service).toBeTruthy();
+    });
+
+    it('verifyLiveness falls back to mock when no backend client', (done) => {
+      service.verifyLiveness('imgdata').subscribe(res => {
+        expect(res.isLive).toBe(true);
+        expect(mockBackendSpy.verifyLiveness).toHaveBeenCalledWith('imgdata', undefined);
+        done();
+      });
+    });
+
+    it('getBackend returns mock backend', () => {
+      const backend = service.getBackend('mock');
+      expect(backend).toBeDefined();
+    });
+
+    it('getAvailableBackends returns mock', () => {
+      const available = service.getAvailableBackends();
+      expect(available).toContain('mock');
+    });
+
+    it('uploadVideoToS3 errors without client', (done) => {
+      service.uploadVideoToS3(new Blob(), 's1').subscribe({
+        error: (err) => {
+          expect(err.message).toContain('Backend HTTP client not configured');
+          done();
+        }
+      });
+    });
+  });
+
+  describe('with backend client', () => {
+    let mockClient: any;
+
+    beforeEach(() => {
+      configServiceSpy = jasmine.createSpyObj('LivenessConfigService', ['getConfig']);
+      configServiceSpy.getConfig.and.returnValue({ backends: ['amazon', 'openpose'] });
+
+      mockClient = {
+        createSession: jest.fn().mockReturnValue(of({ sessionId: 's1' })),
+        analyzeLiveness: jest.fn().mockReturnValue(of({ isLive: true, confidence: 0.9, metadata: {} })),
+        analyzeWithSelectedBackends: jest.fn().mockReturnValue(of({
+          amazon: { isLive: true, confidence: 0.9 },
+          openpose: { isLive: true, confidence: 0.85 },
+          facetec: null,
+          primary: { isLive: true, confidence: 0.9 },
+          consensus: { isLive: true, confidence: 0.875, agreement: 'unanimous' }
+        })),
+        uploadVideo: jest.fn().mockReturnValue(of({ success: true, videoUrl: 'url', sessionId: 's1' })),
+      };
+
+      TestBed.configureTestingModule({
+        providers: [
+          LivenessOrchestratorService,
+          { provide: LivenessConfigService, useValue: configServiceSpy },
+          { provide: MockBackendService, useValue: { isAvailable: () => true, getName: () => 'mock', verifyLiveness: jest.fn() } },
+          { provide: RekognitionAnalysisBackendService, useValue: { isAvailable: () => true, getName: () => 'amazon' } },
+          { provide: OpenPoseBackendService, useValue: { isAvailable: () => true, getName: () => 'openpose' } },
+          { provide: FaceTecBackendService, useValue: { isAvailable: () => false, getName: () => 'facetec' } },
+          { provide: AzureBackendService, useValue: { isAvailable: () => false, getName: () => 'azure' } },
+          { provide: BACKEND_HTTP_CLIENT, useValue: mockClient },
+        ]
+      });
+      service = TestBed.inject(LivenessOrchestratorService);
+    });
+
+    it('verifyLiveness uses multi-backend analysis', (done) => {
+      service.verifyLiveness('imgdata').subscribe(res => {
+        expect(res.isLive).toBe(true);
+        expect(res.confidence).toBe(0.875);
+        expect(mockClient.createSession).toHaveBeenCalled();
+        expect(mockClient.analyzeWithSelectedBackends).toHaveBeenCalled();
+        done();
+      });
+    });
+
+    it('stores multiBackendResult', (done) => {
+      service.verifyLiveness('imgdata').subscribe(() => {
+        expect(service.multiBackendResult).toBeDefined();
+        expect(service.multiBackendResult?.consensus).toBeDefined();
+        done();
+      });
+    });
+
+    it('uploadVideoToS3 delegates to client', (done) => {
+      service.uploadVideoToS3(new Blob(), 's1').subscribe(res => {
+        expect(res.success).toBe(true);
+        expect(mockClient.uploadVideo).toHaveBeenCalled();
+        done();
+      });
+    });
+
+    it('verifyLiveness handles session creation failure', (done) => {
+      mockClient.createSession.mockReturnValue(throwError(() => new Error('Session failed')));
+      service.verifyLiveness('imgdata').subscribe({
+        error: (err) => {
+          expect(err.message).toBe('Session failed');
+          done();
+        }
+      });
+    });
+  });
+});