facecog-liveness-showcase 0.0.1

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

@@ -0,0 +1,699 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { NO_ERRORS_SCHEMA } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { IonicModule, ModalController, AlertController, ToastController, LoadingController } from '@ionic/angular';
+import { FormsModule } from '@angular/forms';
+import { of, throwError } from 'rxjs';
+import { IntroComponent } from './intro.component';
+import { ReferencePoseService } from '../../services/pose-detection/reference-pose.service';
+import { OpenposeService } from '../../services/pose-detection/openpose.service';
+import { PoseSelectionService } from '../../services/pose-selection.service';
+import { LivenessConfigService } from '../../services/liveness-config.service';
+import { CUSTOM_POSE_REPOSITORY } from '../../interfaces/custom-pose-repository.interface';
+
+describe('IntroComponent', () => {
+  let component: IntroComponent;
+  let fixture: ComponentFixture<IntroComponent>;
+  let poseSelectionSpy: any;
+  let configServiceSpy: any;
+  let openposeServiceSpy: any;
+  let referencePoseServiceSpy: any;
+  let modalCtrlSpy: any;
+  let alertCtrlSpy: any;
+  let toastCtrlSpy: any;
+  let loadingCtrlSpy: any;
+
+  beforeEach(async () => {
+    poseSelectionSpy = jasmine.createSpyObj('PoseSelectionService', [
+      'selectPoseByObject', 'getSelectedPose', 'clearSelection', 'selectedPose$'
+    ]);
+    poseSelectionSpy.selectedPose$ = { subscribe: jest.fn((cb: any) => cb(null)) };
+
+    configServiceSpy = jasmine.createSpyObj('LivenessConfigService', ['enableBackends', 'getConfig']);
+    configServiceSpy.getConfig.and.returnValue({ backends: ['amazon'] });
+
+    openposeServiceSpy = jasmine.createSpyObj('OpenposeService', ['loadModel']);
+    openposeServiceSpy.loadModel.and.returnValue(Promise.resolve());
+
+    referencePoseServiceSpy = jasmine.createSpyObj('ReferencePoseService', ['extractPoseFromImage', 'clearReferencePose']);
+
+    modalCtrlSpy = jasmine.createSpyObj('ModalController', ['create']);
+    alertCtrlSpy = jasmine.createSpyObj('AlertController', ['create']);
+    toastCtrlSpy = jasmine.createSpyObj('ToastController', ['create']);
+    loadingCtrlSpy = jasmine.createSpyObj('LoadingController', ['create']);
+
+    await TestBed.configureTestingModule({
+      imports: [CommonModule, IonicModule.forRoot(), FormsModule, IntroComponent],
+      providers: [
+        { provide: ReferencePoseService, useValue: referencePoseServiceSpy },
+        { provide: OpenposeService, useValue: openposeServiceSpy },
+        { provide: PoseSelectionService, useValue: poseSelectionSpy },
+        { provide: LivenessConfigService, useValue: configServiceSpy },
+        { provide: ModalController, useValue: modalCtrlSpy },
+        { provide: AlertController, useValue: alertCtrlSpy },
+        { provide: ToastController, useValue: toastCtrlSpy },
+        { provide: LoadingController, useValue: loadingCtrlSpy },
+      ],
+      schemas: [NO_ERRORS_SCHEMA]
+    }).compileComponents();
+
+    fixture = TestBed.createComponent(IntroComponent);
+    component = fixture.componentInstance;
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+
+  it('has correct default state', () => {
+    expect(component.poseSpecificMode).toBe(false);
+    expect(component.viewMode).toBe('grid');
+    expect(component.showFilters).toBe(false);
+    expect(component.poseSelectionMode).toBe('browse');
+    expect(component.useAwsFaceLiveness).toBe(false);
+  });
+
+  it('displayImage returns exampleImageBase64 first', () => {
+    component.exampleImageBase64 = 'base64data';
+    component.exampleImageUrl = 'http://example.com/img.png';
+    expect(component.displayImage).toBe('base64data');
+  });
+
+  it('displayImage returns exampleImageUrl when no base64', () => {
+    component.exampleImageUrl = 'http://example.com/img.png';
+    expect(component.displayImage).toBe('http://example.com/img.png');
+  });
+
+  it('customPosesEnabled returns false when no repo', () => {
+    expect(component.customPosesEnabled).toBe(false);
+  });
+
+  it('categories returns expected array', () => {
+    expect(component.categories.length).toBeGreaterThan(0);
+    expect(component.categories[0].key).toBe('all');
+  });
+
+  it('difficulties returns expected array', () => {
+    expect(component.difficulties.length).toBe(4);
+  });
+
+  it('filteredPoses returns all poses by default', () => {
+    expect(component.filteredPoses.length).toBe(component.allPoses.length);
+  });
+
+  it('filteredPoses filters by category', () => {
+    component.selectedCategory = 'face';
+    const filtered = component.filteredPoses;
+    expect(filtered.every(p => p.category === 'face')).toBe(true);
+  });
+
+  it('filteredPoses filters by difficulty', () => {
+    component.selectedDifficulty = 'easy';
+    const filtered = component.filteredPoses;
+    expect(filtered.every(p => p.difficulty === 'easy')).toBe(true);
+  });
+
+  it('filteredPoses filters by search query', () => {
+    component.searchQuery = 'smile';
+    const filtered = component.filteredPoses;
+    expect(filtered.every(p =>
+      p.name.toLowerCase().includes('smile') || p.description.toLowerCase().includes('smile')
+    )).toBe(true);
+  });
+
+  it('ngOnInit loads OpenPose model', async () => {
+    await component.ngOnInit();
+    expect(openposeServiceSpy.loadModel).toHaveBeenCalled();
+  });
+
+  it('ngOnInit handles model load failure', async () => {
+    openposeServiceSpy.loadModel.and.returnValue(Promise.reject(new Error('Load failed')));
+    await component.ngOnInit();
+    expect(openposeServiceSpy.loadModel).toHaveBeenCalled();
+  });
+
+  it('onStart emits startClicked', () => {
+    const spy = jest.fn();
+    component.startClicked.subscribe(spy);
+    component.onStart();
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('onCancel emits cancelClicked', () => {
+    const spy = jest.fn();
+    component.cancelClicked.subscribe(spy);
+    component.onCancel();
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('toggleFilters toggles showFilters', () => {
+    expect(component.showFilters).toBe(false);
+    component.toggleFilters();
+    expect(component.showFilters).toBe(true);
+    component.toggleFilters();
+    expect(component.showFilters).toBe(false);
+  });
+
+  it('setViewMode changes viewMode', () => {
+    component.setViewMode('list');
+    expect(component.viewMode).toBe('list');
+    component.setViewMode('grid');
+    expect(component.viewMode).toBe('grid');
+  });
+
+  it('filterByCategory sets selectedCategory', () => {
+    component.filterByCategory('face');
+    expect(component.selectedCategory).toBe('face');
+  });
+
+  it('filterByDifficulty sets selectedDifficulty', () => {
+    component.filterByDifficulty('hard');
+    expect(component.selectedDifficulty).toBe('hard');
+  });
+
+  it('onSearchChange updates searchQuery', () => {
+    component.onSearchChange({ target: { value: 'test' } });
+    expect(component.searchQuery).toBe('test');
+  });
+
+  it('clearFilters resets all filters', () => {
+    component.selectedCategory = 'face';
+    component.selectedDifficulty = 'hard';
+    component.searchQuery = 'test';
+    component.clearFilters();
+    expect(component.selectedCategory).toBe('all');
+    expect(component.selectedDifficulty).toBe('all');
+    expect(component.searchQuery).toBe('');
+  });
+
+  it('getCategoryIcon returns icon string', () => {
+    expect(typeof component.getCategoryIcon('face')).toBe('string');
+  });
+
+  it('getCategoryColor returns color string', () => {
+    expect(typeof component.getCategoryColor('face')).toBe('string');
+  });
+
+  it('getDifficultyColor returns correct colors', () => {
+    expect(component.getDifficultyColor('easy')).toBe('success');
+    expect(component.getDifficultyColor('medium')).toBe('warning');
+    expect(component.getDifficultyColor('hard')).toBe('danger');
+  });
+
+  it('onImageError hides the image element', () => {
+    const mockEvent = { target: { src: 'broken.png', style: { display: '' } } };
+    component.onImageError(mockEvent);
+    expect(mockEvent.target.style.display).toBe('none');
+  });
+
+  it('applyBackendConfig applies selected backends', () => {
+    component.selectedBackends = { amazon: true, openpose: false, facetec: false };
+    component.applyBackendConfig();
+    expect(configServiceSpy.enableBackends).toHaveBeenCalledWith(['amazon']);
+  });
+
+  it('applyBackendConfig defaults to amazon when none selected', () => {
+    component.selectedBackends = { amazon: false, openpose: false, facetec: false };
+    component.applyBackendConfig();
+    expect(configServiceSpy.enableBackends).toHaveBeenCalledWith(['amazon']);
+    expect(component.selectedBackends['amazon']).toBe(true);
+  });
+
+  it('onBackendChange calls applyBackendConfig', () => {
+    const spy = spyOn(component, 'applyBackendConfig');
+    component.onBackendChange();
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('getSelectedBackendCount returns correct count', () => {
+    component.selectedBackends = { amazon: true, openpose: true, facetec: false };
+    expect(component.getSelectedBackendCount()).toBe(2);
+  });
+
+  it('getSelectedBackendName returns backend name', () => {
+    component.selectedBackends = { amazon: true, openpose: false, facetec: false };
+    expect(component.getSelectedBackendName()).toBe('Amazon Rekognition');
+  });
+
+  it('toggleBackendSettings toggles visibility', () => {
+    expect(component.showBackendSettings).toBe(false);
+    component.toggleBackendSettings();
+    expect(component.showBackendSettings).toBe(true);
+  });
+
+  it('onAwsFaceLivenessChange emits toggle value', () => {
+    const spy = jest.fn();
+    component.awsFaceLivenessToggled.subscribe(spy);
+    component.useAwsFaceLiveness = true;
+    component.onAwsFaceLivenessChange();
+    expect(spy).toHaveBeenCalledWith(true);
+  });
+
+  it('onModeChange updates poseSelectionMode', () => {
+    component.onModeChange({ detail: { value: 'upload' } });
+    expect(component.poseSelectionMode).toBe('upload');
+  });
+
+  it('onDragOver sets isDragging', () => {
+    const event = { preventDefault: jest.fn(), stopPropagation: jest.fn() } as any;
+    component.onDragOver(event);
+    expect(component.isDragging).toBe(true);
+  });
+
+  it('onDragLeave clears isDragging', () => {
+    component.isDragging = true;
+    const event = { preventDefault: jest.fn(), stopPropagation: jest.fn() } as any;
+    component.onDragLeave(event);
+    expect(component.isDragging).toBe(false);
+  });
+
+  it('onDrop with no files does nothing', async () => {
+    const event = { preventDefault: jest.fn(), stopPropagation: jest.fn(), dataTransfer: { files: [] } } as any;
+    await component.onDrop(event);
+    expect(component.isDragging).toBe(false);
+  });
+
+  it('onDrop with non-image file sets error status', async () => {
+    const event = {
+      preventDefault: jest.fn(),
+      stopPropagation: jest.fn(),
+      dataTransfer: { files: [{ type: 'text/plain', size: 100 }] }
+    } as any;
+    await component.onDrop(event);
+    expect(component.poseDetectionStatus?.success).toBe(false);
+    expect(component.poseDetectionStatus?.message).toContain('valid image');
+  });
+
+  it('onDrop with oversized file sets error status', async () => {
+    const event = {
+      preventDefault: jest.fn(),
+      stopPropagation: jest.fn(),
+      dataTransfer: { files: [{ type: 'image/png', size: 20 * 1024 * 1024 }] }
+    } as any;
+    await component.onDrop(event);
+    expect(component.poseDetectionStatus?.success).toBe(false);
+    expect(component.poseDetectionStatus?.message).toContain('too large');
+  });
+
+  it('onSelectPose selects pose and emits', () => {
+    const pose = component.allPoses[0];
+    poseSelectionSpy.getSelectedPose.and.returnValue({ pose, imageUrl: '', timestamp: new Date() });
+    const spy = jest.fn();
+    component.poseSelected.subscribe(spy);
+
+    component.onSelectPose(pose);
+
+    expect(poseSelectionSpy.selectPoseByObject).toHaveBeenCalledWith(pose);
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('clearPoseSelection clears selection', () => {
+    component.selectedPose = { pose: component.allPoses[0], imageUrl: '', timestamp: new Date() };
+    component.clearPoseSelection();
+    expect(poseSelectionSpy.clearSelection).toHaveBeenCalled();
+    expect(component.selectedPose).toBeNull();
+  });
+
+  it('isPoseSelected returns correct value', () => {
+    const pose = component.allPoses[0];
+    component.selectedPose = { pose, imageUrl: '', timestamp: new Date() };
+    expect(component.isPoseSelected(pose)).toBe(true);
+    expect(component.isPoseSelected(component.allPoses[1])).toBe(false);
+  });
+
+  it('clearReferencePose resets all reference state', () => {
+    component.referencePoseImage = 'data:image/png;base64,abc';
+    component.referencePoseDescription = 'Test';
+    component.poseDetectionStatus = { success: true, message: 'OK' };
+    component.isSavingCustomPose = true;
+
+    component.clearReferencePose();
+
+    expect(component.referencePoseImage).toBeNull();
+    expect(component.referencePoseDescription).toBeNull();
+    expect(component.poseDetectionStatus).toBeNull();
+    expect(component.isSavingCustomPose).toBe(false);
+    expect(component.poseSelectionMode).toBe('browse');
+    expect(referencePoseServiceSpy.clearReferencePose).toHaveBeenCalled();
+  });
+
+  it('onFileSelected with no files does nothing', async () => {
+    const event = { target: { files: null } } as any;
+    await component.onFileSelected(event);
+    expect(component.isProcessingImage).toBe(false);
+  });
+
+  it('onFileSelected with non-image file sets error', async () => {
+    const event = { target: { files: [{ type: 'text/plain', size: 100 }] } } as any;
+    await component.onFileSelected(event);
+    expect(component.poseDetectionStatus?.success).toBe(false);
+    expect(component.poseDetectionStatus?.message).toContain('valid image');
+  });
+
+  it('onFileSelected with oversized file sets error', async () => {
+    const event = { target: { files: [{ type: 'image/png', size: 20 * 1024 * 1024 }] } } as any;
+    await component.onFileSelected(event);
+    expect(component.poseDetectionStatus?.success).toBe(false);
+    expect(component.poseDetectionStatus?.message).toContain('too large');
+  });
+
+  it('onFileSelected with valid image processes it', async () => {
+    referencePoseServiceSpy.extractPoseFromImage.and.returnValue(Promise.resolve({
+      imageData: 'base64img',
+      poseDescription: 'Detected pose',
+      keypoints: []
+    }));
+    const file = new File(['data'], 'test.png', { type: 'image/png' });
+    const event = { target: { files: [file] } } as any;
+    await component.onFileSelected(event);
+    expect(component.referencePoseImage).toBe('base64img');
+    expect(component.referencePoseDescription).toBe('Detected pose');
+    expect(component.poseDetectionStatus?.success).toBe(true);
+    expect(component.isProcessingImage).toBe(false);
+  });
+
+  it('processReferenceImage handles extraction failure', async () => {
+    referencePoseServiceSpy.extractPoseFromImage.and.returnValue(Promise.reject(new Error('No pose found')));
+    const file = new File(['data'], 'test.png', { type: 'image/png' });
+    const event = { target: { files: [file] } } as any;
+    await component.onFileSelected(event);
+    expect(component.poseDetectionStatus?.success).toBe(false);
+    expect(component.poseDetectionStatus?.message).toBe('No pose found');
+    expect(component.referencePoseImage).toBeNull();
+    expect(component.isProcessingImage).toBe(false);
+  });
+
+  it('onDrop with valid image processes it', async () => {
+    referencePoseServiceSpy.extractPoseFromImage.and.returnValue(Promise.resolve({
+      imageData: 'base64img',
+      poseDescription: 'Detected pose',
+      keypoints: []
+    }));
+    const file = new File(['data'], 'test.png', { type: 'image/png' });
+    const event = {
+      preventDefault: jest.fn(),
+      stopPropagation: jest.fn(),
+      dataTransfer: { files: [file] }
+    } as any;
+    await component.onDrop(event);
+    expect(component.referencePoseImage).toBe('base64img');
+  });
+
+  it('onSelectPose clears reference pose if one exists', () => {
+    component.referencePoseImage = 'base64img';
+    const pose = component.allPoses[0];
+    poseSelectionSpy.getSelectedPose.and.returnValue({ pose, imageUrl: '', timestamp: new Date() });
+
+    component.onSelectPose(pose);
+
+    expect(referencePoseServiceSpy.clearReferencePose).toHaveBeenCalled();
+    expect(component.referencePoseImage).toBeNull();
+  });
+
+  it('onSaveCustomPose returns early when already saving', async () => {
+    component.isSavingCustomPose = true;
+    await component.onSaveCustomPose();
+    expect(toastCtrlSpy.create).not.toHaveBeenCalled();
+  });
+
+  it('onSaveCustomPose shows warning when no pose', async () => {
+    component.referencePoseImage = null;
+    toastCtrlSpy.create.and.returnValue(Promise.resolve({ present: jest.fn() }));
+    await component.onSaveCustomPose();
+    expect(toastCtrlSpy.create).toHaveBeenCalled();
+  });
+
+  it('onDeleteCustomPose returns early for non-custom pose', async () => {
+    const pose = { ...component.allPoses[0], isCustom: false };
+    const event = { stopPropagation: jest.fn() } as any;
+    await component.onDeleteCustomPose(pose, event);
+    expect(event.stopPropagation).toHaveBeenCalled();
+    expect(alertCtrlSpy.create).not.toHaveBeenCalled();
+  });
+
+  it('getSelectedBackendName returns Unknown for no selection', () => {
+    component.selectedBackends = { amazon: false, openpose: false, facetec: false };
+    expect(component.getSelectedBackendName()).toBe('Unknown');
+  });
+
+  it('onStart warns when no pose selected', () => {
+    component.selectedPose = null;
+    const spy = jest.fn();
+    component.startClicked.subscribe(spy);
+    component.onStart();
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('processReferenceImage clears existing pose selection', async () => {
+    component.selectedPose = { pose: component.allPoses[0], imageUrl: '', timestamp: new Date() };
+    referencePoseServiceSpy.extractPoseFromImage.and.returnValue(Promise.resolve({
+      imageData: 'base64img',
+      poseDescription: 'Test',
+      keypoints: []
+    }));
+    const file = new File(['data'], 'test.png', { type: 'image/png' });
+    const event = { target: { files: [file] } } as any;
+    await component.onFileSelected(event);
+    expect(poseSelectionSpy.clearSelection).toHaveBeenCalled();
+  });
+
+  it('customPosesEnabled returns false when no repo', () => {
+    expect(component.customPosesEnabled).toBe(false);
+  });
+
+  it('onSaveCustomPose shows warning when customPoses not enabled', async () => {
+    component.referencePoseImage = 'data:image/png;base64,abc';
+    component['referencePose'] = { poseDescription: 'Test', keypoints: [], imageData: '' } as any;
+    toastCtrlSpy.create.and.returnValue(Promise.resolve({ present: jest.fn() }));
+    await component.onSaveCustomPose();
+    expect(toastCtrlSpy.create).toHaveBeenCalled();
+  });
+
+  it('detectSafariBrowser sets isSafariBrowser', () => {
+    (component as any).detectSafariBrowser();
+    expect(typeof component.isSafariBrowser).toBe('boolean');
+  });
+});
+
+describe('IntroComponent with CustomPoseRepository', () => {
+  let component: IntroComponent;
+  let fixture: ComponentFixture<IntroComponent>;
+  let customPoseRepoSpy: any;
+  let modalCtrlSpy2: any;
+  let alertCtrlSpy2: any;
+  let toastCtrlSpy2: any;
+  let loadingCtrlSpy2: any;
+
+  beforeEach(async () => {
+    const poseSelectionSpy = {
+      selectPoseByObject: jest.fn(),
+      getSelectedPose: jest.fn().mockReturnValue(null),
+      clearSelection: jest.fn(),
+      selectedPose$: { subscribe: jest.fn((cb: any) => cb(null)) }
+    };
+
+    const configServiceSpy = {
+      enableBackends: jest.fn(),
+      getConfig: jest.fn().mockReturnValue({ backends: ['amazon'] })
+    };
+
+    const openposeServiceSpy = {
+      loadModel: jest.fn().mockResolvedValue(undefined)
+    };
+
+    const referencePoseServiceSpy = {
+      extractPoseFromImage: jest.fn(),
+      clearReferencePose: jest.fn()
+    };
+
+    customPoseRepoSpy = {
+      loadCustomPoses: jest.fn().mockReturnValue(of({ success: false, poses: [] })),
+      createCustomPoseFromBase64: jest.fn(),
+      deleteCustomPose: jest.fn()
+    };
+
+    modalCtrlSpy2 = { create: jest.fn() };
+    alertCtrlSpy2 = { create: jest.fn() };
+    toastCtrlSpy2 = { create: jest.fn() };
+    loadingCtrlSpy2 = { create: jest.fn() };
+
+    await TestBed.configureTestingModule({
+      imports: [CommonModule, IonicModule.forRoot(), FormsModule, IntroComponent],
+      providers: [
+        { provide: ReferencePoseService, useValue: referencePoseServiceSpy },
+        { provide: OpenposeService, useValue: openposeServiceSpy },
+        { provide: PoseSelectionService, useValue: poseSelectionSpy },
+        { provide: LivenessConfigService, useValue: configServiceSpy },
+        { provide: ModalController, useValue: modalCtrlSpy2 },
+        { provide: AlertController, useValue: alertCtrlSpy2 },
+        { provide: ToastController, useValue: toastCtrlSpy2 },
+        { provide: LoadingController, useValue: loadingCtrlSpy2 },
+        { provide: CUSTOM_POSE_REPOSITORY, useValue: customPoseRepoSpy },
+      ],
+      schemas: [NO_ERRORS_SCHEMA]
+    })
+    .overrideComponent(IntroComponent, {
+      set: {
+        providers: [
+          { provide: ModalController, useValue: modalCtrlSpy2 },
+          { provide: AlertController, useValue: alertCtrlSpy2 },
+          { provide: ToastController, useValue: toastCtrlSpy2 },
+          { provide: LoadingController, useValue: loadingCtrlSpy2 },
+        ]
+      }
+    })
+    .compileComponents();
+
+    fixture = TestBed.createComponent(IntroComponent);
+    component = fixture.componentInstance;
+  });
+
+  it('customPosesEnabled returns true when repo provided', () => {
+    expect(component.customPosesEnabled).toBe(true);
+  });
+
+  it('onSaveCustomPose saves new pose successfully', async () => {
+    component.referencePoseImage = 'data:image/png;base64,abc';
+    component['referencePose'] = { poseDescription: 'Test', keypoints: [], imageData: '' } as any;
+
+    modalCtrlSpy2.create.mockResolvedValue({
+      present: jest.fn().mockResolvedValue(undefined),
+      onWillDismiss: jest.fn().mockResolvedValue({
+        data: { name: 'My Pose', description: 'Test', category: 'face', difficulty: 'easy' }
+      })
+    });
+    loadingCtrlSpy2.create.mockResolvedValue({
+      present: jest.fn().mockResolvedValue(undefined),
+      dismiss: jest.fn().mockResolvedValue(undefined)
+    });
+    customPoseRepoSpy.createCustomPoseFromBase64.mockResolvedValue({
+      pose: { id: 1, name: 'My Pose', description: 'Test', category: 'face', difficulty: 'easy', imageUrl: '' },
+      isNew: true
+    });
+    toastCtrlSpy2.create.mockResolvedValue({ present: jest.fn().mockResolvedValue(undefined) });
+
+    await component.onSaveCustomPose();
+
+    expect(customPoseRepoSpy.createCustomPoseFromBase64).toHaveBeenCalled();
+    expect(toastCtrlSpy2.create).toHaveBeenCalled();
+    expect(component.isSavingCustomPose).toBe(false);
+  });
+
+  it('onSaveCustomPose handles duplicate pose', async () => {
+    component.referencePoseImage = 'data:image/png;base64,abc';
+    component['referencePose'] = { poseDescription: 'Test', keypoints: [], imageData: '' } as any;
+
+    modalCtrlSpy2.create.mockResolvedValue({
+      present: jest.fn().mockResolvedValue(undefined),
+      onWillDismiss: jest.fn().mockResolvedValue({
+        data: { name: 'My Pose', description: 'Test', category: 'face', difficulty: 'easy' }
+      })
+    });
+    loadingCtrlSpy2.create.mockResolvedValue({
+      present: jest.fn().mockResolvedValue(undefined),
+      dismiss: jest.fn().mockResolvedValue(undefined)
+    });
+    customPoseRepoSpy.createCustomPoseFromBase64.mockResolvedValue({
+      pose: { id: 1, name: 'Existing Pose' },
+      isNew: false
+    });
+    toastCtrlSpy2.create.mockResolvedValue({ present: jest.fn().mockResolvedValue(undefined) });
+
+    await component.onSaveCustomPose();
+
+    expect(toastCtrlSpy2.create).toHaveBeenCalled();
+  });
+
+  it('onSaveCustomPose handles user cancelling dialog', async () => {
+    component.referencePoseImage = 'data:image/png;base64,abc';
+    component['referencePose'] = { poseDescription: 'Test', keypoints: [], imageData: '' } as any;
+
+    modalCtrlSpy2.create.mockResolvedValue({
+      present: jest.fn().mockResolvedValue(undefined),
+      onWillDismiss: jest.fn().mockResolvedValue({ data: null })
+    });
+
+    await component.onSaveCustomPose();
+
+    expect(customPoseRepoSpy.createCustomPoseFromBase64).not.toHaveBeenCalled();
+  });
+
+  it('onSaveCustomPose handles API error', async () => {
+    component.referencePoseImage = 'data:image/png;base64,abc';
+    component['referencePose'] = { poseDescription: 'Test', keypoints: [], imageData: '' } as any;
+
+    modalCtrlSpy2.create.mockResolvedValue({
+      present: jest.fn().mockResolvedValue(undefined),
+      onWillDismiss: jest.fn().mockResolvedValue({
+        data: { name: 'My Pose', description: 'Test', category: 'face', difficulty: 'easy' }
+      })
+    });
+    loadingCtrlSpy2.create.mockResolvedValue({
+      present: jest.fn().mockResolvedValue(undefined),
+      dismiss: jest.fn().mockResolvedValue(undefined)
+    });
+    customPoseRepoSpy.createCustomPoseFromBase64.mockRejectedValue(new Error('API error'));
+    toastCtrlSpy2.create.mockResolvedValue({ present: jest.fn().mockResolvedValue(undefined) });
+
+    await component.onSaveCustomPose();
+
+    expect(component.isSavingCustomPose).toBe(false);
+    expect(toastCtrlSpy2.create).toHaveBeenCalled();
+  });
+
+  it('onDeleteCustomPose deletes custom pose', async () => {
+    const customPose = { id: 10001, name: 'Custom', isCustom: true } as any;
+
+    alertCtrlSpy2.create.mockResolvedValue({
+      present: jest.fn().mockResolvedValue(undefined),
+      onDidDismiss: jest.fn().mockResolvedValue({ role: 'destructive' })
+    });
+    loadingCtrlSpy2.create.mockResolvedValue({
+      present: jest.fn().mockResolvedValue(undefined),
+      dismiss: jest.fn().mockResolvedValue(undefined)
+    });
+    customPoseRepoSpy.deleteCustomPose.mockReturnValue({ toPromise: () => Promise.resolve() });
+    toastCtrlSpy2.create.mockResolvedValue({ present: jest.fn().mockResolvedValue(undefined) });
+
+    component.allPoses = [customPose];
+    const event = { stopPropagation: jest.fn() } as any;
+    await component.onDeleteCustomPose(customPose, event);
+
+    expect(customPoseRepoSpy.deleteCustomPose).toHaveBeenCalledWith(1);
+    expect(component.allPoses.length).toBe(0);
+  });
+
+  it('onDeleteCustomPose handles user cancellation', async () => {
+    const customPose = { id: 10001, name: 'Custom', isCustom: true } as any;
+
+    alertCtrlSpy2.create.mockResolvedValue({
+      present: jest.fn().mockResolvedValue(undefined),
+      onDidDismiss: jest.fn().mockResolvedValue({ role: 'cancel' })
+    });
+
+    const event = { stopPropagation: jest.fn() } as any;
+    await component.onDeleteCustomPose(customPose, event);
+
+    expect(customPoseRepoSpy.deleteCustomPose).not.toHaveBeenCalled();
+  });
+
+  it('onDeleteCustomPose handles API error', async () => {
+    const customPose = { id: 10001, name: 'Custom', isCustom: true } as any;
+
+    alertCtrlSpy2.create.mockResolvedValue({
+      present: jest.fn().mockResolvedValue(undefined),
+      onDidDismiss: jest.fn().mockResolvedValue({ role: 'destructive' })
+    });
+    loadingCtrlSpy2.create.mockResolvedValue({
+      present: jest.fn().mockResolvedValue(undefined),
+      dismiss: jest.fn().mockResolvedValue(undefined)
+    });
+    customPoseRepoSpy.deleteCustomPose.mockReturnValue({ toPromise: () => Promise.reject(new Error('Delete failed')) });
+    toastCtrlSpy2.create.mockResolvedValue({ present: jest.fn().mockResolvedValue(undefined) });
+
+    const event = { stopPropagation: jest.fn() } as any;
+    await component.onDeleteCustomPose(customPose, event);
+
+    expect(toastCtrlSpy2.create).toHaveBeenCalled();
+  });
+});