facecog-liveness-showcase 0.0.1

package/projects/facecog-liveness-verification/src/lib/components/liveness-flow/liveness-flow.component.spec.ts

@@ -0,0 +1,673 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { Type } from '@angular/core';
+import { NO_ERRORS_SCHEMA } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { IonicModule } from '@ionic/angular';
+import { of, throwError as rxThrowError } from 'rxjs';
+
+import { LivenessFlowComponent } from './liveness-flow.component';
+import { LivenessConfigService } from '../../services/liveness-config.service';
+import { LivenessOrchestratorService } from '../../services/liveness-orchestrator.service';
+import { PoseSelectionService } from '../../services/pose-selection.service';
+import { VerificationApiService } from '../../services/verification-api.service';
+import { AWS_FACE_LIVENESS_COMPONENT } from '../../models/constants/aws-face-liveness-component.token';
+import type { LivenessBackend } from '../../types/liveness-backend.type';
+import type { LivenessResult } from '../../interfaces/liveness-result.interface';
+import type { SelectedPoseInfo } from '../../services/pose-selection.service';
+
+describe('LivenessFlowComponent', () => {
+  let component: LivenessFlowComponent;
+  let fixture: ComponentFixture<LivenessFlowComponent>;
+  let configServiceSpy: jasmine.SpyObj<LivenessConfigService>;
+  let orchestratorSpy: jasmine.SpyObj<LivenessOrchestratorService>;
+  let poseSelectionSpy: jasmine.SpyObj<PoseSelectionService>;
+  let verificationApiSpy: jasmine.SpyObj<VerificationApiService>;
+
+  const defaultConfig = {
+    apiUrl: 'http://localhost:3002',
+    backends: ['amazon'] as LivenessBackend[],
+    maxRetries: 3,
+    showIntroScreen: true,
+    customPose: undefined,
+    poseId: undefined
+  };
+
+  const mockSelectedPose: SelectedPoseInfo = {
+    pose: { id: 1, name: 'Smile', description: 'Smile', category: 'face', imagePath: '', detectionStrategy: 'face-api', difficulty: 'easy' },
+    imageUrl: 'assets/smile.png',
+    timestamp: new Date()
+  };
+
+  beforeEach(async () => {
+    configServiceSpy = jasmine.createSpyObj('LivenessConfigService', ['getConfig', 'updateConfig']);
+    configServiceSpy.getConfig.and.returnValue({ ...defaultConfig });
+
+    orchestratorSpy = jasmine.createSpyObj('LivenessOrchestratorService', ['verifyLiveness', 'uploadVideoToS3']);
+    poseSelectionSpy = jasmine.createSpyObj('PoseSelectionService', ['getSelectedPose']);
+    poseSelectionSpy.getSelectedPose.and.returnValue(null);
+
+    verificationApiSpy = jasmine.createSpyObj('VerificationApiService', ['startSession', 'verifyGestures', 'verifyFaceTec', 'finalize']);
+
+    await TestBed.configureTestingModule({
+      imports: [
+        CommonModule,
+        IonicModule.forRoot(),
+        LivenessFlowComponent
+      ],
+      providers: [
+        { provide: LivenessConfigService, useValue: configServiceSpy },
+        { provide: LivenessOrchestratorService, useValue: orchestratorSpy },
+        { provide: PoseSelectionService, useValue: poseSelectionSpy },
+        { provide: VerificationApiService, useValue: verificationApiSpy },
+        { provide: AWS_FACE_LIVENESS_COMPONENT, useValue: null }
+      ],
+      schemas: [NO_ERRORS_SCHEMA]
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(LivenessFlowComponent);
+    component = fixture.componentInstance;
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+
+  it('ngOnInit sets config from LivenessConfigService', () => {
+    const libConfig = { ...defaultConfig, backends: undefined };
+    configServiceSpy.getConfig.and.returnValue(libConfig);
+
+    component.ngOnInit();
+
+    expect(component.config).toBeDefined();
+    expect(component.config.backends).toEqual(['amazon']);
+    expect(configServiceSpy.getConfig).toHaveBeenCalled();
+  });
+
+  it('should skip intro when showIntroScreen is false and customPose is set', () => {
+    configServiceSpy.getConfig.and.returnValue({
+      ...defaultConfig,
+      showIntroScreen: false,
+      customPose: { imageData: 'base64...', description: 'Custom pose' }
+    });
+    poseSelectionSpy.getSelectedPose.and.returnValue(mockSelectedPose);
+
+    component.ngOnInit();
+
+    expect(component.currentStep()).toBe('permission');
+    expect(component.selectedPose).toEqual(mockSelectedPose);
+  });
+
+  it('should skip intro when showIntroScreen is false and poseId is set', () => {
+    configServiceSpy.getConfig.and.returnValue({
+      ...defaultConfig,
+      showIntroScreen: false,
+      poseId: 5
+    });
+    poseSelectionSpy.getSelectedPose.and.returnValue(mockSelectedPose);
+
+    component.ngOnInit();
+
+    expect(component.currentStep()).toBe('permission');
+  });
+
+  it('should not skip intro when showIntroScreen is true', () => {
+    configServiceSpy.getConfig.and.returnValue({
+      ...defaultConfig,
+      showIntroScreen: true
+    });
+
+    component.ngOnInit();
+
+    expect(component.currentStep()).toBe('intro');
+  });
+
+  it('onStartClicked sets currentStep to permission', () => {
+    component.currentStep.set('intro');
+    component.onStartClicked();
+
+    expect(component.currentStep()).toBe('permission');
+  });
+
+  it('onPermissionGranted sets currentStep to preview', () => {
+    component.currentStep.set('permission');
+    component.onPermissionGranted();
+
+    expect(component.currentStep()).toBe('preview');
+  });
+
+  it('onPermissionDenied emits result via resultSubject', (done) => {
+    component.result$.subscribe((result) => {
+      expect(result.success).toBe(false);
+      expect(result.error).toBe('Camera permission denied');
+      done();
+    });
+
+    component.onPermissionDenied();
+  });
+
+  it('onRetry resets state and sets currentStep to preview', () => {
+    component.currentStep.set('result');
+    component.attemptCount = 1;
+    component.capturedFrames = ['frame1'];
+    component.result.set({ success: false, confidence: 0, verifiedImage: '', metadata: {} as any });
+    component.config = { ...defaultConfig, maxRetries: 3 } as any;
+
+    component.onRetry();
+
+    expect(component.currentStep()).toBe('preview');
+    expect(component.processingProgress()).toBe(0);
+    expect(component.capturedFrames).toEqual([]);
+    expect(component.result()).toBeNull();
+  });
+
+  it('onRetry when max retries reached emits error result', (done) => {
+    component.attemptCount = 3;
+    component.config = { ...defaultConfig, maxRetries: 3 } as any;
+    component.result.set({
+      success: false,
+      confidence: 0,
+      verifiedImage: '',
+      error: 'Previous error',
+      metadata: { timestamp: '', backend: 'amazon', confidence: 0, attemptNumber: 3 }
+    });
+
+    component.result$.subscribe((result) => {
+      expect(result.error).toBe('Maximum retry attempts reached');
+      done();
+    });
+
+    component.onRetry();
+  });
+
+  it('onCancel emits cancelled result and resets currentStep to intro', () => {
+    component.currentStep.set('result');
+    let emittedResult: any;
+    component.result$.subscribe((r) => (emittedResult = r));
+
+    component.onCancel();
+
+    expect(emittedResult.success).toBe(false);
+    expect(emittedResult.error).toBe('User cancelled');
+    expect(component.currentStep()).toBe('intro');
+  });
+
+  it('emitResult resets currentStep to intro', () => {
+    component.currentStep.set('result');
+    const testResult: LivenessResult = {
+      success: true,
+      confidence: 0.95,
+      verifiedImage: 'img',
+      metadata: { timestamp: '', backend: 'amazon' as LivenessBackend, confidence: 0.95, attemptNumber: 1 }
+    };
+    let emittedResult: any;
+    component.result$.subscribe((r) => (emittedResult = r));
+
+    (component as any).emitResult(testResult);
+
+    expect(emittedResult).toEqual(testResult);
+    expect(component.currentStep()).toBe('intro');
+  });
+
+  it('onDone emits the current result when result exists', (done) => {
+    const testResult: LivenessResult = {
+      success: true,
+      confidence: 0.9,
+      verifiedImage: 'img',
+      metadata: { timestamp: '', backend: 'amazon' as LivenessBackend, confidence: 0.9, attemptNumber: 1 }
+    };
+    component.result.set(testResult);
+
+    component.result$.subscribe((result) => {
+      expect(result).toEqual(testResult);
+      done();
+    });
+
+    component.onDone();
+  });
+
+  it('onDone does not emit when result is null', () => {
+    component.result.set(null);
+    let emitted = false;
+    component.result$.subscribe(() => (emitted = true));
+    component.onDone();
+    expect(emitted).toBe(false);
+  });
+
+  it('startLivenessFlow returns result$ observable', () => {
+    const obs = component.startLivenessFlow();
+    expect(obs).toBe(component.result$);
+  });
+
+  it('startLivenessFlow with config updates config', () => {
+    configServiceSpy.getConfig.and.returnValue({ ...defaultConfig, showIntroScreen: true });
+    component.startLivenessFlow({ maxRetries: 5 });
+    expect(configServiceSpy.updateConfig).toHaveBeenCalledWith({ maxRetries: 5 });
+  });
+
+  it('onCaptureComplete sets capturedFrames and videoBlob', async () => {
+    const mockBlob = new Blob(['video'], { type: 'video/webm' });
+    verificationApiSpy.startSession.and.returnValue(rxThrowError(() => new Error('API unavailable')));
+
+    await component.onCaptureComplete({ frames: ['frame1', 'frame2'], videoBlob: mockBlob });
+
+    expect(component.capturedFrames).toEqual(['frame1', 'frame2']);
+    expect(component.videoBlob).toBe(mockBlob);
+    expect(component.currentStep()).toBe('result');
+    expect(component.result()?.success).toBe(false);
+  });
+
+  it('onCaptureComplete handles session creation failure', async () => {
+    verificationApiSpy.startSession.and.returnValue(of(null as any));
+
+    await component.onCaptureComplete({ frames: ['frame1'] });
+
+    expect(component.currentStep()).toBe('result');
+    expect(component.result()?.success).toBe(false);
+    expect(component.result()?.error).toContain('Failed to create verification session');
+  });
+
+  it('onFaceTecScanComplete with failed result sets step to result', async () => {
+    await component.onFaceTecScanComplete({ success: false, error: 'Scan failed' } as any);
+
+    expect(component.currentStep()).toBe('result');
+    expect(component.result()?.success).toBe(false);
+    expect(component.result()?.error).toBe('Scan failed');
+  });
+
+  it('onFaceTecScanCancelled calls onCancel', () => {
+    let emittedResult: any;
+    component.result$.subscribe((r) => (emittedResult = r));
+
+    component.onFaceTecScanCancelled();
+
+    expect(emittedResult.error).toBe('User cancelled');
+    expect(component.currentStep()).toBe('intro');
+  });
+
+  it('onAwsFaceLivenessComplete with failed result sets step to result', async () => {
+    await component.onAwsFaceLivenessComplete({ success: false, error: 'AWS check failed' } as any);
+
+    expect(component.currentStep()).toBe('result');
+    expect(component.result()?.success).toBe(false);
+    expect(component.result()?.error).toBe('AWS check failed');
+  });
+
+  it('onAwsFaceLivenessCancelled calls onCancel', () => {
+    let emittedResult: any;
+    component.result$.subscribe((r) => (emittedResult = r));
+
+    component.onAwsFaceLivenessCancelled();
+
+    expect(emittedResult.error).toBe('User cancelled');
+  });
+
+  it('onReferencePoseUploaded sets referencePose', () => {
+    const pose = { poseDescription: 'Test', keypoints: [] } as any;
+    component.onReferencePoseUploaded(pose);
+    expect(component.referencePose).toBe(pose);
+  });
+
+  it('onPoseSelected sets selectedPose', () => {
+    component.onPoseSelected(mockSelectedPose);
+    expect(component.selectedPose).toBe(mockSelectedPose);
+  });
+
+  it('onAwsFaceLivenessToggled sets useAwsFaceLiveness', () => {
+    component.onAwsFaceLivenessToggled(true);
+    expect(component.useAwsFaceLiveness).toBe(true);
+    component.onAwsFaceLivenessToggled(false);
+    expect(component.useAwsFaceLiveness).toBe(false);
+  });
+
+  it('poseSpecificMode returns true when customPose is set', () => {
+    configServiceSpy.getConfig.and.returnValue({ ...defaultConfig, customPose: { imageData: 'x', description: 'y' } });
+    expect(component.poseSpecificMode).toBe(true);
+  });
+
+  it('poseSpecificMode returns true when poseId > 0', () => {
+    configServiceSpy.getConfig.and.returnValue({ ...defaultConfig, poseId: 5 });
+    expect(component.poseSpecificMode).toBe(true);
+  });
+
+  it('poseSpecificMode returns false when neither customPose nor poseId set', () => {
+    configServiceSpy.getConfig.and.returnValue({ ...defaultConfig });
+    expect(component.poseSpecificMode).toBe(false);
+  });
+
+  it('ngOnDestroy calls destroyDynamicAwsComponent', () => {
+    const destroySpy = spyOn(component as any, 'destroyDynamicAwsComponent');
+    component.ngOnDestroy();
+    expect(destroySpy).toHaveBeenCalled();
+  });
+
+  it('awsFaceLivenessInputs returns correct config', () => {
+    component.awsRegion = 'eu-west-1';
+    const inputs = component.awsFaceLivenessInputs;
+    expect(inputs.region).toBe('eu-west-1');
+    expect(inputs.autoStart).toBe(true);
+    expect(inputs.showCancelButton).toBe(true);
+  });
+
+  it('onCaptureComplete with successful session goes to facetec step', async () => {
+    verificationApiSpy.startSession.and.returnValue(of({ sessionId: 'sess-1', plan: [] }));
+    verificationApiSpy.verifyGestures.and.returnValue(of({ success: true, frameHash: 'hash123' }));
+
+    await component.onCaptureComplete({ frames: ['frame1'] });
+
+    expect(component.verificationSessionId).toBe('sess-1');
+    expect(component.gestureFrameHash).toBe('hash123');
+    expect(component.currentStep()).toBe('facetec');
+  });
+
+  it('onCaptureComplete with useAwsFaceLiveness goes to aws-liveness step', async () => {
+    component.useAwsFaceLiveness = true;
+    verificationApiSpy.startSession.and.returnValue(of({ sessionId: 'sess-1', plan: [] }));
+    verificationApiSpy.verifyGestures.and.returnValue(of({ success: true, frameHash: 'hash123' }));
+
+    await component.onCaptureComplete({ frames: ['frame1'] });
+
+    expect(component.currentStep()).toBe('aws-liveness');
+  });
+
+  it('onCaptureComplete handles gesture verification failure', async () => {
+    verificationApiSpy.startSession.and.returnValue(of({ sessionId: 'sess-1', plan: [] }));
+    verificationApiSpy.verifyGestures.and.returnValue(of(null as any));
+
+    await component.onCaptureComplete({ frames: ['frame1'] });
+
+    expect(component.currentStep()).toBe('result');
+    expect(component.result()?.success).toBe(false);
+    expect(component.result()?.error).toContain('Gesture verification failed');
+  });
+
+  it('onFaceTecScanComplete with success goes to processing', async () => {
+    component.capturedFrames = ['frame1'];
+    orchestratorSpy.verifyLiveness.and.returnValue({
+      subscribe: (obs: any) => { obs.next({ isLive: true, confidence: 0.9 }); }
+    } as any);
+    orchestratorSpy.multiBackendResult = null;
+    verificationApiSpy.verifyFaceTec.and.returnValue(of({ success: true }));
+    verificationApiSpy.finalize.and.returnValue(of({ allPassed: true, confidence: 0.92 }));
+
+    await component.onFaceTecScanComplete({
+      success: true,
+      faceScan: 'scan-data',
+      auditTrailImage: 'img',
+      lowQualityAuditTrailImage: 'img-low'
+    } as any);
+
+    expect(component.result()?.success).toBe(true);
+    expect(component.result()?.confidence).toBe(0.92);
+    expect(component.currentStep()).toBe('result');
+  });
+
+  it('onAwsFaceLivenessComplete with success processes verification', async () => {
+    component.capturedFrames = ['frame1'];
+    orchestratorSpy.verifyLiveness.and.returnValue({
+      subscribe: (obs: any) => { obs.next({ isLive: true, confidence: 0.88 }); }
+    } as any);
+    orchestratorSpy.multiBackendResult = null;
+
+    await component.onAwsFaceLivenessComplete({
+      success: true,
+      isLive: true,
+      confidence: 0.95,
+      sessionId: 'aws-sess'
+    } as any);
+
+    expect(component.result()?.success).toBe(true);
+    expect(component.currentStep()).toBe('result');
+  });
+
+  it('processMultiBackendVerification handles orchestrator error', async () => {
+    component.capturedFrames = ['frame1'];
+    orchestratorSpy.verifyLiveness.and.returnValue({
+      subscribe: (obs: any) => { obs.error(new Error('Backend down')); }
+    } as any);
+
+    await (component as any).processMultiBackendVerification();
+
+    expect(component.result()?.success).toBe(false);
+    expect(component.result()?.error).toBe('Backend down');
+    expect(component.currentStep()).toBe('result');
+  });
+
+  it('processMultiBackendVerification succeeds with backend response', async () => {
+    component.capturedFrames = ['frame1'];
+    orchestratorSpy.verifyLiveness.and.returnValue({
+      subscribe: (obs: any) => { obs.next({ isLive: true, confidence: 0.91 }); }
+    } as any);
+    orchestratorSpy.multiBackendResult = null;
+
+    await (component as any).processMultiBackendVerification();
+
+    expect(component.result()?.success).toBe(true);
+    expect(component.result()?.confidence).toBe(0.91);
+    expect(component.currentStep()).toBe('result');
+    expect(component.processingProgress()).toBe(100);
+  });
+
+  it('processHybridVerification handles error', async () => {
+    component.capturedFrames = ['frame1'];
+    component.faceTecResult = { success: true, faceScan: 'scan' } as any;
+    orchestratorSpy.verifyLiveness.and.returnValue({
+      subscribe: (obs: any) => { obs.error(new Error('Hybrid failed')); }
+    } as any);
+
+    await (component as any).processHybridVerification();
+
+    expect(component.result()?.success).toBe(false);
+    expect(component.result()?.error).toBe('Hybrid failed');
+    expect(component.currentStep()).toBe('result');
+  });
+
+  it('processAwsFaceLivenessVerification handles error', async () => {
+    component.capturedFrames = ['frame1'];
+    component.awsFaceLivenessResult = { success: true, isLive: true, confidence: 0.95 } as any;
+    orchestratorSpy.verifyLiveness.and.returnValue({
+      subscribe: (obs: any) => { obs.error(new Error('AWS verify failed')); }
+    } as any);
+
+    await (component as any).processAwsFaceLivenessVerification();
+
+    expect(component.result()?.success).toBe(false);
+    expect(component.result()?.error).toBe('AWS verify failed');
+    expect(component.currentStep()).toBe('result');
+  });
+
+  it('onAwsFaceLivenessCancelled cleans up subscriptions', () => {
+    const mockSub = { unsubscribe: jest.fn() };
+    (component as any).awsOutputSubs = [mockSub];
+    let emittedResult: any;
+    component.result$.subscribe((r) => (emittedResult = r));
+
+    component.onAwsFaceLivenessCancelled();
+
+    expect(mockSub.unsubscribe).toHaveBeenCalled();
+    expect(emittedResult.error).toBe('User cancelled');
+  });
+
+  it('shouldSkipIntro returns true when showIntroScreen false and customPose set', () => {
+    configServiceSpy.getConfig.and.returnValue({
+      ...defaultConfig,
+      showIntroScreen: false,
+      customPose: { imageData: 'x', description: 'y' }
+    });
+    expect((component as any).shouldSkipIntro()).toBe(true);
+  });
+
+  it('shouldSkipIntro returns false when showIntroScreen true', () => {
+    configServiceSpy.getConfig.and.returnValue({ ...defaultConfig, showIntroScreen: true });
+    expect((component as any).shouldSkipIntro()).toBe(false);
+  });
+
+  it('ngAfterViewChecked triggers createDynamicAwsComponent when conditions met', () => {
+    component.currentStep.set('aws-liveness');
+    component['awsFaceLivenessComponent'] = {} as any;
+    component['awsComponentCreated'] = false;
+    // Mock createDynamicAwsComponent to avoid actually creating a component
+    const origCreate = (component as any).createDynamicAwsComponent;
+    let createCalled = false;
+    (component as any).createDynamicAwsComponent = () => { createCalled = true; };
+    component['awsLivenessContainer'] = { clear: jest.fn() } as any;
+
+    component.ngAfterViewChecked();
+
+    expect(createCalled).toBe(true);
+    // Restore
+    (component as any).createDynamicAwsComponent = origCreate;
+  });
+
+  it('ngAfterViewChecked destroys AWS component when leaving step', () => {
+    component.currentStep.set('result');
+    component['awsComponentCreated'] = true;
+    component['awsComponentRef'] = { destroy: jest.fn() } as any;
+
+    component.ngAfterViewChecked();
+
+    expect(component['awsComponentCreated']).toBe(false);
+  });
+
+  it('ngAfterViewChecked does nothing when not on aws-liveness step', () => {
+    component.currentStep.set('intro');
+    component['awsComponentCreated'] = false;
+
+    component.ngAfterViewChecked();
+
+    expect(component['awsComponentCreated']).toBe(false);
+  });
+
+  it('createDynamicAwsComponent subscribes to outputs', () => {
+    const mockScanComplete = { subscribe: jest.fn().mockReturnValue({ unsubscribe: jest.fn() }) };
+    const mockScanCancelled = { subscribe: jest.fn().mockReturnValue({ unsubscribe: jest.fn() }) };
+
+    component['awsFaceLivenessComponent'] = {} as any;
+    component['awsLivenessContainer'] = {
+      clear: jest.fn(),
+      createComponent: jest.fn().mockReturnValue({
+        instance: {
+          region: '',
+          autoStart: false,
+          showCancelButton: false,
+          scanComplete: mockScanComplete,
+          scanCancelled: mockScanCancelled
+        },
+        changeDetectorRef: { detectChanges: jest.fn() }
+      })
+    } as any;
+
+    (component as any).createDynamicAwsComponent();
+
+    expect(mockScanComplete.subscribe).toHaveBeenCalled();
+    expect(mockScanCancelled.subscribe).toHaveBeenCalled();
+    expect(component['awsOutputSubs'].length).toBe(2);
+
+    // Clean up to prevent Angular teardown errors
+    component['awsComponentRef'] = null as any;
+    component['awsComponentCreated'] = false;
+  });
+
+  it('createDynamicAwsComponent is safe without container', () => {
+    component['awsFaceLivenessComponent'] = {} as any;
+    component['awsLivenessContainer'] = null as any;
+    expect(() => (component as any).createDynamicAwsComponent()).not.toThrow();
+  });
+
+  it('processMultiBackendVerification uploads video when blob exists', async () => {
+    component.capturedFrames = ['frame1'];
+    component.videoBlob = new Blob(['video']);
+    const mockMultiResult = {
+      primary: { metadata: { sessionId: 'sess-1' } },
+      amazon: null, openpose: null, facetec: null, consensus: { isLive: true, confidence: 0.91 }
+    } as any;
+    orchestratorSpy.verifyLiveness.and.returnValue({
+      subscribe: (obs: any) => { obs.next({ isLive: true, confidence: 0.91 }); }
+    } as any);
+    orchestratorSpy.multiBackendResult = mockMultiResult;
+    orchestratorSpy.uploadVideoToS3.and.returnValue({
+      subscribe: (obs: any) => { obs.next({ videoUrl: 'https://s3.example.com/video.webm' }); }
+    } as any);
+
+    await (component as any).processMultiBackendVerification();
+
+    expect(orchestratorSpy.uploadVideoToS3).toHaveBeenCalled();
+    expect(component.result()?.videoUrl).toBe('https://s3.example.com/video.webm');
+    expect(component.result()?.success).toBe(true);
+  });
+
+  it('processMultiBackendVerification handles video upload failure gracefully', async () => {
+    component.capturedFrames = ['frame1'];
+    component.videoBlob = new Blob(['video']);
+    const mockMultiResult = {
+      primary: { metadata: { sessionId: 'sess-1' } },
+      amazon: null, openpose: null, facetec: null, consensus: { isLive: true, confidence: 0.91 }
+    } as any;
+    orchestratorSpy.verifyLiveness.and.returnValue({
+      subscribe: (obs: any) => { obs.next({ isLive: true, confidence: 0.91 }); }
+    } as any);
+    orchestratorSpy.multiBackendResult = mockMultiResult;
+    orchestratorSpy.uploadVideoToS3.and.returnValue({
+      subscribe: (obs: any) => { obs.error(new Error('Upload failed')); }
+    } as any);
+
+    await (component as any).processMultiBackendVerification();
+
+    expect(component.result()?.success).toBe(true);
+    expect(component.result()?.videoUrl).toBeUndefined();
+  });
+
+  it('processHybridVerification succeeds with full flow', async () => {
+    component.capturedFrames = ['frame1'];
+    component.faceTecResult = { success: true, faceScan: 'scan' } as any;
+    orchestratorSpy.verifyLiveness.and.returnValue({
+      subscribe: (obs: any) => { obs.next({ isLive: true, confidence: 0.9 }); }
+    } as any);
+    orchestratorSpy.multiBackendResult = null;
+    verificationApiSpy.verifyFaceTec.and.returnValue(of({ success: true }));
+    verificationApiSpy.finalize.and.returnValue(of({ allPassed: true, confidence: 0.95 }));
+
+    await (component as any).processHybridVerification();
+
+    expect(component.result()?.success).toBe(true);
+    expect(component.result()?.confidence).toBe(0.95);
+    expect(component.currentStep()).toBe('result');
+  });
+
+  it('processAwsFaceLivenessVerification succeeds', async () => {
+    component.capturedFrames = ['frame1'];
+    component.awsFaceLivenessResult = { success: true, isLive: true, confidence: 0.95 } as any;
+    orchestratorSpy.verifyLiveness.and.returnValue({
+      subscribe: (obs: any) => { obs.next({ isLive: true, confidence: 0.88 }); }
+    } as any);
+    orchestratorSpy.multiBackendResult = null;
+
+    await (component as any).processAwsFaceLivenessVerification();
+
+    expect(component.result()?.success).toBe(true);
+    const avgConf = (0.95 + 0.88) / 2;
+    expect(component.result()?.confidence).toBeCloseTo(avgConf, 2);
+    expect(component.currentStep()).toBe('result');
+  });
+
+  it('processAwsFaceLivenessVerification uploads video when available', async () => {
+    component.capturedFrames = ['frame1'];
+    component.videoBlob = new Blob(['video']);
+    component.awsFaceLivenessResult = { success: true, isLive: true, confidence: 0.95 } as any;
+    const mockMultiResult = {
+      primary: { metadata: { sessionId: 'sess-1' } },
+      amazon: null, openpose: null, facetec: null, consensus: { isLive: true, confidence: 0.88 }
+    } as any;
+    orchestratorSpy.verifyLiveness.and.returnValue({
+      subscribe: (obs: any) => { obs.next({ isLive: true, confidence: 0.88 }); }
+    } as any);
+    orchestratorSpy.multiBackendResult = mockMultiResult;
+    orchestratorSpy.uploadVideoToS3.and.returnValue({
+      subscribe: (obs: any) => { obs.next({ videoUrl: 'https://s3.example.com/video.webm' }); }
+    } as any);
+
+    await (component as any).processAwsFaceLivenessVerification();
+
+    expect(orchestratorSpy.uploadVideoToS3).toHaveBeenCalled();
+    expect(component.result()?.videoUrl).toBe('https://s3.example.com/video.webm');
+  });
+});