facecog-liveness-showcase 0.0.1

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

@@ -0,0 +1,605 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { NgZone } from '@angular/core';
+import { NO_ERRORS_SCHEMA } from '@angular/core';
+import { IonicModule } from '@ionic/angular';
+import { CommonModule } from '@angular/common';
+
+import { LivePreviewComponent } from './live-preview.component';
+import { VideoRecorderService } from '../../services/video-recorder.service';
+import { PoseMatchingService } from '../../services/pose-detection/pose-matching.service';
+import { LivenessConfigService } from '../../services/liveness-config.service';
+import { CAMERA_PROVIDER } from '../../interfaces/camera-provider.interface';
+import type { SelectedPoseInfo } from '../../services/pose-selection.service';
+import type { PoseDefinition } from '../../interfaces/pose-definition.interface';
+
+describe('LivePreviewComponent', () => {
+  let component: LivePreviewComponent;
+  let fixture: ComponentFixture<LivePreviewComponent>;
+  let videoRecorderSpy: jasmine.SpyObj<VideoRecorderService>;
+  let poseMatchingSpy: jasmine.SpyObj<PoseMatchingService>;
+  let configServiceSpy: jasmine.SpyObj<LivenessConfigService>;
+  let ngZoneRunSpy: jasmine.Spy;
+  const mockPose: PoseDefinition = {
+    id: 1,
+    name: 'Smile',
+    description: 'Smile naturally',
+    category: 'face',
+    imagePath: 'assets/smile.png',
+    detectionStrategy: 'face-api',
+    difficulty: 'easy'
+  };
+
+  const mockSelectedPose: SelectedPoseInfo = {
+    pose: mockPose,
+    imageUrl: 'assets/smile.png',
+    timestamp: new Date()
+  };
+
+  beforeEach(async () => {
+    videoRecorderSpy = jasmine.createSpyObj('VideoRecorderService', ['startRecording', 'stopRecording', 'isRecording', 'cleanup']);
+    videoRecorderSpy.isRecording.and.returnValue(false);
+
+    poseMatchingSpy = jasmine.createSpyObj('PoseMatchingService', [
+      'loadModels',
+      'loadReferenceImage',
+      'resetActionState',
+      'setStaticPoseKeypoints',
+      'setExpectedGesture',
+      'setCombinedPoseType',
+      'detectAction',
+      'frameToBase64',
+      'cleanup'
+    ]);
+    poseMatchingSpy.loadModels.and.returnValue(Promise.resolve());
+    poseMatchingSpy.loadReferenceImage.and.returnValue(Promise.resolve());
+    poseMatchingSpy.detectAction.and.returnValue(Promise.resolve({ action: 'smile', progress: 0.5, completed: false, message: 'Hold...' }));
+    poseMatchingSpy.frameToBase64.and.returnValue('base64frame');
+
+    configServiceSpy = jasmine.createSpyObj('LivenessConfigService', ['getConfig']);
+    configServiceSpy.getConfig.and.returnValue({
+      exampleImageUrl: undefined,
+      enableVideoRecording: false,
+      captureFrameCount: 5
+    });
+
+    const mockCameraProvider = {
+      startBrightnessMonitoring: jasmine.createSpy('startBrightnessMonitoring').and.returnValue(12345),
+      stopBrightnessMonitoring: jasmine.createSpy('stopBrightnessMonitoring')
+    };
+
+    await TestBed.configureTestingModule({
+      imports: [CommonModule, IonicModule.forRoot(), LivePreviewComponent],
+      providers: [
+        { provide: VideoRecorderService, useValue: videoRecorderSpy },
+        { provide: PoseMatchingService, useValue: poseMatchingSpy },
+        { provide: LivenessConfigService, useValue: configServiceSpy },
+        { provide: CAMERA_PROVIDER, useValue: mockCameraProvider }
+      ],
+      schemas: [NO_ERRORS_SCHEMA]
+    }).compileComponents();
+
+    Object.defineProperty(navigator, 'mediaDevices', {
+      value: {
+        getUserMedia: jasmine.createSpy('getUserMedia').and.returnValue(
+          Promise.resolve(new MediaStream())
+        )
+      },
+      configurable: true
+    });
+
+    const ngZone = TestBed.inject(NgZone);
+    ngZoneRunSpy = spyOn(ngZone, 'run').and.callFake((fn: (...args: any[]) => any) => fn());
+
+    fixture = TestBed.createComponent(LivePreviewComponent);
+    component = fixture.componentInstance;
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+
+  it('ngOnInit calls poseMatching.loadModels() and sets statusMessage', async () => {
+    fixture.detectChanges();
+    await fixture.whenStable();
+
+    expect(poseMatchingSpy.loadModels).toHaveBeenCalled();
+    expect(component.statusMessage()).toBeDefined();
+  });
+
+  it('startPoseMatching sets showPoseOverlay to true', () => {
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    component.stream.set({ getTracks: () => [] } as any);
+
+    component.startPoseMatching();
+
+    expect(component.showPoseOverlay()).toBe(true);
+    expect(poseMatchingSpy.resetActionState).toHaveBeenCalled();
+  });
+
+  it('startPoseMatching uses correct pose action based on selectedPose (smile)', () => {
+    component.selectedPose = mockSelectedPose;
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    component.stream.set({ getTracks: () => [] } as any);
+
+    component.startPoseMatching();
+
+    expect(component.currentPoseAction()).toBe('smile');
+    expect(component.currentPoseDescription()).toBe('Smile naturally');
+  });
+
+  it('startPoseMatching uses custom-pose when pose has keypoints', () => {
+    const poseWithKeypoints = {
+      ...mockPose,
+      poseKeypoints: [{ x: 0, y: 0, confidence: 1 }, { x: 1, y: 1, confidence: 1 }]
+    };
+    component.selectedPose = { ...mockSelectedPose, pose: poseWithKeypoints };
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    component.stream.set({ getTracks: () => [] } as any);
+
+    component.startPoseMatching();
+
+    expect(component.currentPoseAction()).toBe('custom-pose');
+    expect(poseMatchingSpy.setStaticPoseKeypoints).toHaveBeenCalledWith(poseWithKeypoints.poseKeypoints);
+  });
+
+  it('captureFrames clears matching interval, sets isMatching, emits captureComplete', async () => {
+    component['matchingInterval'] = setInterval(() => {}, 999) as any;
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    configServiceSpy.getConfig.and.returnValue({ captureFrameCount: 2, enableVideoRecording: false });
+
+    let emitted: { frames: string[]; videoBlob?: Blob } | undefined;
+    component.captureComplete.subscribe((data) => (emitted = data));
+
+    await component.captureFrames();
+
+    expect(component.isMatching()).toBe(true);
+    expect(emitted).toBeDefined();
+    expect(emitted!.frames.length).toBe(2);
+    expect(ngZoneRunSpy).toHaveBeenCalled();
+  });
+
+  it('onCancel emits cancelled', () => {
+    let emitted = false;
+    component.cancelled.subscribe(() => (emitted = true));
+    component.onCancel();
+    expect(emitted).toBe(true);
+  });
+
+  it('handleBrightnessData updates lighting state', () => {
+    (component as any).handleBrightnessData({
+      brightness: 50,
+      isLowLight: true,
+      isTooLight: false
+    });
+
+    expect(component.brightnessLevel()).toBe(50);
+    expect(component.isLowLight()).toBe(true);
+    expect(component.lightingWarning()).toContain('Low light');
+  });
+
+  it('ngOnDestroy cleans up intervals and streams', () => {
+    const trackStopSpy = jasmine.createSpy('stop');
+    component.stream.set({ getTracks: () => [{ stop: trackStopSpy }] } as any);
+    component['matchingInterval'] = setInterval(() => {}, 1000) as any;
+
+    component.ngOnDestroy();
+
+    expect(poseMatchingSpy.cleanup).toHaveBeenCalled();
+    expect(videoRecorderSpy.cleanup).toHaveBeenCalled();
+    expect(trackStopSpy).toHaveBeenCalled();
+  });
+
+  it('handleBrightnessData with too-bright light', () => {
+    (component as any).handleBrightnessData({
+      brightness: 210,
+      isLowLight: false,
+      isTooLight: true
+    });
+    expect(component.isTooLight()).toBe(true);
+    expect(component.lightingWarning()).toContain('Too bright');
+  });
+
+  it('handleBrightnessData with good lighting', () => {
+    (component as any).handleBrightnessData({
+      brightness: 128,
+      isLowLight: false,
+      isTooLight: false
+    });
+    expect(component.isLowLight()).toBe(false);
+    expect(component.isTooLight()).toBe(false);
+    expect(component.lightingWarning()).toBe('');
+  });
+
+  it('captureFrames with video recording stops recorder', async () => {
+    component['matchingInterval'] = setInterval(() => {}, 999) as any;
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    configServiceSpy.getConfig.and.returnValue({ captureFrameCount: 2, enableVideoRecording: true });
+    videoRecorderSpy.isRecording.and.returnValue(true);
+    videoRecorderSpy.stopRecording.and.returnValue(Promise.resolve({ blob: new Blob(), sizeMB: 0.5, duration: 3 }));
+
+    let emitted: any;
+    component.captureComplete.subscribe((data) => (emitted = data));
+
+    await component.captureFrames();
+    await new Promise(r => setTimeout(r, 50));
+
+    expect(videoRecorderSpy.stopRecording).toHaveBeenCalled();
+  });
+
+  it('stopDotAnimation clears dot interval', () => {
+    component['dotAnimationInterval'] = setInterval(() => {}, 1000) as any;
+    component['stopDotAnimation']();
+    expect(component['dotAnimationInterval']).toBeNull();
+  });
+
+  it('startPoseMatching with no selectedPose uses default action', () => {
+    component.selectedPose = undefined;
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    component.stream.set({ getTracks: () => [] } as any);
+
+    component.startPoseMatching();
+
+    expect(component.currentPoseAction()).toBeDefined();
+  });
+
+  it('ngOnDestroy is safe with no stream', () => {
+    component.stream.set(null);
+    expect(() => component.ngOnDestroy()).not.toThrow();
+  });
+
+  it('progressOffset computes correctly', () => {
+    component.matchProgress.set(50);
+    const offset = component.progressOffset();
+    expect(offset).toBe(1515 * 0.5);
+  });
+
+  it('progressOffset is full circumference at 0%', () => {
+    component.matchProgress.set(0);
+    expect(component.progressOffset()).toBe(1515);
+  });
+
+  it('startCamera sets up stream and starts pose matching', async () => {
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    await component.startCamera();
+
+    expect(navigator.mediaDevices.getUserMedia).toHaveBeenCalled();
+    expect(component.stream()).toBeDefined();
+    expect(component.statusMessage()).toBeDefined();
+    expect(component.showPoseOverlay()).toBe(true);
+  });
+
+  it('startCamera handles NotAllowedError', async () => {
+    (navigator.mediaDevices.getUserMedia as jasmine.Spy).and.returnValue(
+      Promise.reject(Object.assign(new Error('Denied'), { name: 'NotAllowedError' }))
+    );
+    await component.startCamera();
+    expect(component.statusMessage()).toContain('Camera access denied');
+  });
+
+  it('startCamera handles NotFoundError', async () => {
+    (navigator.mediaDevices.getUserMedia as jasmine.Spy).and.returnValue(
+      Promise.reject(Object.assign(new Error('Not found'), { name: 'NotFoundError' }))
+    );
+    await component.startCamera();
+    expect(component.statusMessage()).toContain('No camera found');
+  });
+
+  it('startCamera handles NotReadableError', async () => {
+    (navigator.mediaDevices.getUserMedia as jasmine.Spy).and.returnValue(
+      Promise.reject(Object.assign(new Error('In use'), { name: 'NotReadableError' }))
+    );
+    await component.startCamera();
+    expect(component.statusMessage()).toContain('already in use');
+  });
+
+  it('startCamera handles generic error', async () => {
+    (navigator.mediaDevices.getUserMedia as jasmine.Spy).and.returnValue(Promise.reject(new Error('Unknown')));
+    await component.startCamera();
+    expect(component.statusMessage()).toContain('Camera error');
+  });
+
+  it('startCamera with video recording enabled starts recorder', async () => {
+    configServiceSpy.getConfig.and.returnValue({ enableVideoRecording: true, captureFrameCount: 5 });
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    videoRecorderSpy.startRecording.and.returnValue(Promise.resolve());
+
+    await component.startCamera();
+
+    expect(videoRecorderSpy.startRecording).toHaveBeenCalled();
+  });
+
+  it('ngOnInit loads models and starts camera', async () => {
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    fixture.detectChanges();
+    await fixture.whenStable();
+
+    expect(poseMatchingSpy.loadModels).toHaveBeenCalled();
+    expect(component.statusMessage()).toBeDefined();
+  });
+
+  it('ngOnInit with reference image loads it', async () => {
+    configServiceSpy.getConfig.and.returnValue({ exampleImageUrl: 'http://example.com/ref.png', captureFrameCount: 5 });
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+
+    await component.ngOnInit();
+
+    expect(poseMatchingSpy.loadReferenceImage).toHaveBeenCalledWith('http://example.com/ref.png');
+  });
+
+  it('ngOnInit handles model load failure', async () => {
+    poseMatchingSpy.loadModels.and.returnValue(Promise.reject(new Error('Model load failed')));
+
+    await component.ngOnInit();
+
+    expect(component.statusMessage()).toContain('Failed to initialize');
+  });
+
+  it('startPoseMatching with referencePose uses custom-pose action', () => {
+    component.selectedPose = undefined;
+    component.referencePose = { poseDescription: 'Custom pose', keypoints: [], imageData: '' } as any;
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    component.stream.set({ getTracks: () => [] } as any);
+
+    component.startPoseMatching();
+
+    expect(component.currentPoseAction()).toBe('custom-pose');
+    expect(component.currentPoseDescription()).toBe('Custom pose');
+  });
+
+  it('startPoseMatching with follow-dot pose starts dot animation', () => {
+    const followDotPose = {
+      ...mockPose,
+      name: 'Follow Dot',
+      description: 'Follow the dot with your eyes'
+    };
+    component.selectedPose = { ...mockSelectedPose, pose: followDotPose };
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    component.stream.set({ getTracks: () => [] } as any);
+
+    const startDotSpy = spyOn(component as any, 'startDotAnimation');
+    component.startPoseMatching();
+
+    expect(startDotSpy).toHaveBeenCalled();
+  });
+
+  it('startPoseMatching with no keypoints uses fallback detection', () => {
+    const poseNoKeypoints = { ...mockPose, poseKeypoints: undefined };
+    component.selectedPose = { ...mockSelectedPose, pose: poseNoKeypoints };
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    component.stream.set({ getTracks: () => [] } as any);
+
+    component.startPoseMatching();
+
+    expect(poseMatchingSpy.setStaticPoseKeypoints).toHaveBeenCalledWith(null);
+  });
+
+  it('getPoseAction maps palm pose to hand-gesture', () => {
+    const palmPose = { ...mockPose, name: 'Right Palm', poseKeypoints: undefined };
+    const action = (component as any).getPoseAction(palmPose);
+    expect(action).toBe('hand-gesture');
+    expect(poseMatchingSpy.setExpectedGesture).toHaveBeenCalledWith('palm', 'Right');
+  });
+
+  it('getPoseAction maps thumbs up to hand-gesture', () => {
+    const thumbsPose = { ...mockPose, name: 'Thumbs Up', poseKeypoints: undefined };
+    const action = (component as any).getPoseAction(thumbsPose);
+    expect(action).toBe('hand-gesture');
+    expect(poseMatchingSpy.setExpectedGesture).toHaveBeenCalledWith('thumbs_up', 'Any');
+  });
+
+  it('getPoseAction maps peace to hand-gesture', () => {
+    const peacePose = { ...mockPose, name: 'Left Peace Sign', poseKeypoints: undefined };
+    const action = (component as any).getPoseAction(peacePose);
+    expect(action).toBe('hand-gesture');
+    expect(poseMatchingSpy.setExpectedGesture).toHaveBeenCalledWith('peace', 'Left');
+  });
+
+  it('getPoseAction maps ok sign to hand-gesture', () => {
+    const pose = { ...mockPose, name: 'OK Sign', poseKeypoints: undefined };
+    expect((component as any).getPoseAction(pose)).toBe('hand-gesture');
+    expect(poseMatchingSpy.setExpectedGesture).toHaveBeenCalledWith('ok', 'Any');
+  });
+
+  it('getPoseAction maps fist to hand-gesture', () => {
+    const pose = { ...mockPose, name: 'Right Fist', poseKeypoints: undefined };
+    expect((component as any).getPoseAction(pose)).toBe('hand-gesture');
+    expect(poseMatchingSpy.setExpectedGesture).toHaveBeenCalledWith('fist', 'Right');
+  });
+
+  it('getPoseAction maps three fingers to hand-gesture', () => {
+    const pose = { ...mockPose, name: 'Three Fingers', poseKeypoints: undefined };
+    expect((component as any).getPoseAction(pose)).toBe('hand-gesture');
+    expect(poseMatchingSpy.setExpectedGesture).toHaveBeenCalledWith('three', 'Any');
+  });
+
+  it('getPoseAction maps five fingers to hand-gesture', () => {
+    const pose = { ...mockPose, name: 'Five Fingers', poseKeypoints: undefined };
+    expect((component as any).getPoseAction(pose)).toBe('hand-gesture');
+    expect(poseMatchingSpy.setExpectedGesture).toHaveBeenCalledWith('palm', 'Any');
+  });
+
+  it('getPoseAction maps face expressions', () => {
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Open Mouth', poseKeypoints: undefined })).toBe('open-mouth');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Raise Eyebrows', poseKeypoints: undefined })).toBe('raise-eyebrows');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Blink Twice', poseKeypoints: undefined })).toBe('blink-twice');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Blink', poseKeypoints: undefined })).toBe('blink');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Wink', poseKeypoints: undefined })).toBe('wink');
+  });
+
+  it('getPoseAction maps head movements', () => {
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Nod', poseKeypoints: undefined })).toBe('nod');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Turn Left', poseKeypoints: undefined })).toBe('turn-left');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Turn Right', poseKeypoints: undefined })).toBe('turn-right');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Tilt Left', poseKeypoints: undefined })).toBe('tilt-left');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Tilt Right', poseKeypoints: undefined })).toBe('tilt-right');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Look Up', poseKeypoints: undefined })).toBe('look-up');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Look Down', poseKeypoints: undefined })).toBe('look-down');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Shake Head', poseKeypoints: undefined })).toBe('shake-head');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Rotate Face', poseKeypoints: undefined })).toBe('rotate-face');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Face Straight Center', poseKeypoints: undefined })).toBe('face-center');
+  });
+
+  it('getPoseAction maps movement gestures', () => {
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Wave', poseKeypoints: undefined })).toBe('wave');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Clap', poseKeypoints: undefined })).toBe('clap');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Cross Arms', poseKeypoints: undefined })).toBe('cross-arms');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Point', poseKeypoints: undefined })).toBe('point');
+  });
+
+  it('getPoseAction maps combined poses', () => {
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Touch Nose', poseKeypoints: undefined })).toBe('combined-pose');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Cover Eyes', poseKeypoints: undefined })).toBe('combined-pose');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Frame Face', poseKeypoints: undefined })).toBe('combined-pose');
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Hand to Ear', poseKeypoints: undefined })).toBe('combined-pose');
+  });
+
+  it('getPoseAction maps follow dot', () => {
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Follow Dot', poseKeypoints: undefined })).toBe('follow-dot');
+  });
+
+  it('getPoseAction maps speak phrase', () => {
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Speak Phrase', poseKeypoints: undefined })).toBe('speak-phrase');
+  });
+
+  it('getPoseAction defaults face category to smile', () => {
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Unknown Face', category: 'face', poseKeypoints: undefined })).toBe('smile');
+  });
+
+  it('getPoseAction defaults head category to face-center', () => {
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Unknown Head', category: 'head', poseKeypoints: undefined })).toBe('face-center');
+  });
+
+  it('getPoseAction falls back to custom-pose for unmapped', () => {
+    expect((component as any).getPoseAction({ ...mockPose, name: 'Totally Unknown', category: 'gesture', poseKeypoints: undefined })).toBe('custom-pose');
+  });
+
+  it('startDotAnimation sets up interval', () => {
+    (component as any).startDotAnimation();
+    expect(component.showFollowDot()).toBe(true);
+    expect(component['dotAnimationInterval']).toBeDefined();
+    (component as any).stopDotAnimation();
+  });
+
+  it('stopDotAnimation clears interval and hides dot', () => {
+    (component as any).startDotAnimation();
+    (component as any).stopDotAnimation();
+    expect(component.showFollowDot()).toBe(false);
+    expect(component['dotAnimationInterval']).toBeNull();
+  });
+
+  it('manualCapture calls captureFrames', () => {
+    const spy = spyOn(component, 'captureFrames');
+    spy.and.returnValue(Promise.resolve());
+    component.manualCapture();
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('onCancel emits cancelled event', () => {
+    const spy = jest.fn();
+    component.cancelled.subscribe(spy);
+    component.onCancel();
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('startBrightnessMonitoring without video element returns early', () => {
+    component['videoElement'] = null as any;
+    (component as any).startBrightnessMonitoring();
+    expect(component['brightnessMonitoringId']).toBeNull();
+  });
+
+  it('startBrightnessMonitoring without cameraProvider uses fallback interval', () => {
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    component['cameraProvider'] = undefined;
+    (component as any).startBrightnessMonitoring();
+    expect(component['brightnessMonitoringId']).toBeDefined();
+    clearInterval(component['brightnessMonitoringId']!);
+  });
+
+  it('startBrightnessMonitoring with cameraProvider uses provider', () => {
+    const mockProvider = { startBrightnessMonitoring: jasmine.createSpy('startBrightnessMonitoring').and.returnValue(42) };
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    component['cameraProvider'] = mockProvider as any;
+    (component as any).startBrightnessMonitoring();
+    expect(mockProvider.startBrightnessMonitoring).toHaveBeenCalled();
+    expect(component['brightnessMonitoringId']).toBe(42);
+  });
+
+  it('stopBrightnessMonitoring with cameraProvider calls provider stop', () => {
+    const mockProvider = { stopBrightnessMonitoring: jasmine.createSpy('stopBrightnessMonitoring') };
+    component['cameraProvider'] = mockProvider as any;
+    component['brightnessMonitoringId'] = 42;
+    (component as any).stopBrightnessMonitoring();
+    expect(mockProvider.stopBrightnessMonitoring).toHaveBeenCalledWith(42);
+    expect(component['brightnessMonitoringId']).toBeNull();
+  });
+
+  it('stopBrightnessMonitoring without cameraProvider clears interval', () => {
+    component['cameraProvider'] = undefined;
+    component['brightnessMonitoringId'] = setInterval(() => {}, 9999) as any;
+    (component as any).stopBrightnessMonitoring();
+    expect(component['brightnessMonitoringId']).toBeNull();
+  });
+
+  it('analyzeBrightness returns brightness data', () => {
+    const video = document.createElement('video');
+    const result = (component as any).analyzeBrightness(video);
+    expect(result).toHaveProperty('brightness');
+    expect(result).toHaveProperty('isLowLight');
+    expect(result).toHaveProperty('isTooLight');
+  });
+
+  it('captureFrames captures correct number of frames and emits', async () => {
+    component['matchingInterval'] = setInterval(() => {}, 999) as any;
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    configServiceSpy.getConfig.and.returnValue({ captureFrameCount: 2, enableVideoRecording: false });
+    poseMatchingSpy.frameToBase64.and.returnValue('data:image/png;base64,frame');
+
+    let emitted: any;
+    component.captureComplete.subscribe((data: any) => (emitted = data));
+
+    await component.captureFrames();
+    await new Promise(r => setTimeout(r, 50));
+
+    expect((component as any).capturedFrames.length).toBe(2);
+    expect(component.isMatching()).toBe(true);
+  });
+
+  it('pose matching interval handles detection error', async () => {
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    component.stream.set({ getTracks: () => [] } as any);
+    poseMatchingSpy.detectAction.and.returnValue(Promise.reject(new Error('Detection failed')));
+
+    component.startPoseMatching();
+    await new Promise(r => setTimeout(r, 300));
+    clearInterval(component['matchingInterval']);
+
+    expect(component.statusMessage()).toContain('Unable to detect');
+  });
+
+  it('pose matching interval completes when result.completed is true', async () => {
+    component['videoElement'] = { nativeElement: document.createElement('video') } as any;
+    component.stream.set({ getTracks: () => [] } as any);
+    poseMatchingSpy.detectAction.and.returnValue(Promise.resolve({ completed: true, progress: 1, message: 'Done' }));
+    poseMatchingSpy.frameToBase64.and.returnValue('data:image/png;base64,frame');
+    configServiceSpy.getConfig.and.returnValue({ captureFrameCount: 1, enableVideoRecording: false });
+
+    component.startPoseMatching();
+    await new Promise(r => setTimeout(r, 400));
+
+    expect(component.statusMessage()).toContain('Capturing');
+  });
+
+  it('ngOnDestroy cleans up canvasAnimationFrame', () => {
+    component['canvasAnimationFrame'] = 123;
+    component.stream.set(new MediaStream());
+    component.ngOnDestroy();
+    expect(component['canvasAnimationFrame']).toBe(123);
+  });
+
+  it('updateDotPosition sets dotX and dotY', () => {
+    component['currentDotIndex'] = 0;
+    (component as any).updateDotPosition(1000, 800);
+    expect(component.dotX()).toBe(500);
+    expect(component.dotY()).toBe(160);
+  });
+});