pdf-oxide 0.3.24

package/src/tests/final-utilities.test.ts

@@ -0,0 +1,455 @@
+/**
+ * Comprehensive test suite for Phase 8 Final Utilities.
+ * Tests: EventManager, EncryptionManager, CompressionManager, CustomAnnotationManager, ContentSecurityManager
+ */
+
+import { describe, it, expect, beforeEach } from '@jest/globals';
+
+import EventManager from '../managers/event-manager';
+import EncryptionManager from '../managers/encryption-manager';
+import CompressionManager from '../managers/compression-manager';
+import CustomAnnotationManager from '../managers/custom-annotation-manager';
+import ContentSecurityManager from '../managers/content-security-manager';
+
+describe('Phase 8 Final Utilities', () => {
+  describe('EventManager', () => {
+    let manager: EventManager;
+
+    beforeEach(() => {
+      manager = new EventManager();
+    });
+
+    it('should add event listener and return true', () => {
+      const handler = (e: any) => {};
+      const result = manager.addEventListener('PAGE_LOADED', handler);
+      expect(result).toBe(true);
+    });
+
+    it('should remove event listener and return true', () => {
+      const handler = (e: any) => {};
+      manager.addEventListener('PAGE_LOADED', handler);
+      const result = manager.removeEventListener('PAGE_LOADED', handler);
+      expect(result).toBe(true);
+    });
+
+    it('should check if listener exists', () => {
+      const handler = (e: any) => {};
+      manager.addEventListener('CONTENT_PARSED', handler);
+      const result = manager.hasListener('CONTENT_PARSED');
+      expect(result).toBe(true);
+    });
+
+    it('should return false for non-existent listener', () => {
+      const result = manager.hasListener('ERROR_OCCURRED');
+      expect(result).toBe(false);
+    });
+
+    it('should count listeners correctly', () => {
+      manager.addEventListener('PAGE_RENDERED', (e: any) => {});
+      manager.addEventListener('PAGE_RENDERED', (e: any) => {});
+      const count = manager.getListenerCount('PAGE_RENDERED');
+      expect(count).toBe(2);
+    });
+
+    it('should clear listeners for event', () => {
+      manager.addEventListener('SEARCH_COMPLETED', (e: any) => {});
+      const result = manager.clearListeners('SEARCH_COMPLETED');
+      expect(result).toBe(true);
+      expect(manager.getListenerCount('SEARCH_COMPLETED')).toBe(0);
+    });
+
+    it('should get event statistics as object', () => {
+      manager.addEventListener('PAGE_LOADED', (e: any) => {});
+      manager.addEventListener('CONTENT_PARSED', (e: any) => {});
+      const stats = manager.getEventStatistics();
+      expect(typeof stats).toBe('object');
+    });
+
+    it('should enable event logging and return boolean', () => {
+      const result = manager.enableEventLogging(true);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should emit event and call handlers', () => {
+      let called = false;
+      const handler = (e: any) => {
+        called = true;
+      };
+      manager.addEventListener('PAGE_LOADED', handler);
+      // Event emission would be tested in integration
+    });
+  });
+
+  describe('EncryptionManager', () => {
+    let manager: EncryptionManager;
+
+    beforeEach(() => {
+      manager = new EncryptionManager();
+    });
+
+    it('should encrypt document with settings and return boolean', () => {
+      const settings = {
+        algorithm: 'AES_256',
+        user_password: 'user123',
+        owner_password: 'owner123',
+        allow_printing: true,
+        allow_copying: false,
+        allow_modification: false,
+      };
+      const result = manager.encryptDocument(settings);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should decrypt document and return boolean', () => {
+      const result = manager.decryptDocument('password123');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should change encryption settings and return boolean', () => {
+      const settings = { algorithm: 'AES_256' };
+      const result = manager.changeEncryption(settings);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should check encryption status and return boolean', () => {
+      const result = manager.isDocumentEncrypted();
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should set user password and return boolean', () => {
+      const result = manager.setUserPassword('newpass123');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should set owner password and return boolean', () => {
+      const result = manager.setOwnerPassword('ownerpass123');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should validate password and return boolean', () => {
+      const result = manager.validatePassword('testpass');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should get permissions as object', () => {
+      const perms = manager.getPermissions();
+      expect(typeof perms).toBe('object');
+    });
+
+    it('should set permissions and return boolean', () => {
+      const perms = { allow_print: true, allow_copy: false };
+      const result = manager.setPermissions(perms);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should remove encryption and return boolean', () => {
+      const result = manager.removeEncryption('ownerpass');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should support all encryption algorithms', () => {
+      const algorithms = ['AES_128', 'AES_256', 'RC4_40', 'RC4_128'];
+
+      for (const algo of algorithms) {
+        const settings = {
+          algorithm: algo,
+          user_password: 'user',
+          owner_password: 'owner',
+        };
+        const result = manager.encryptDocument(settings);
+        expect(typeof result).toBe('boolean');
+      }
+    });
+  });
+
+  describe('CompressionManager', () => {
+    let manager: CompressionManager;
+
+    beforeEach(() => {
+      manager = new CompressionManager();
+    });
+
+    it('should compress document with settings and return boolean', () => {
+      const settings = {
+        level: 'BALANCED',
+        compress_images: true,
+        compress_streams: true,
+        compress_fonts: true,
+        remove_duplicates: true,
+      };
+      const result = manager.compressDocument(settings);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should compress images with quality and return boolean', () => {
+      const result = manager.compressImages(85);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should compress streams and return boolean', () => {
+      const result = manager.compressStreams();
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should compress specific page and return boolean', () => {
+      const settings = { level: 'BALANCED' };
+      const result = manager.compressPage(0, settings);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should check compression status and return boolean', () => {
+      const result = manager.isCompressed();
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should decompress document and return boolean', () => {
+      const result = manager.decompressDocument();
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should get compression ratio as number or null', () => {
+      const ratio = manager.getCompressionRatio();
+      expect(ratio === null || typeof ratio === 'number').toBe(true);
+    });
+
+    it('should get compression report as object', () => {
+      const report = manager.getCompressionReport();
+      expect(typeof report).toBe('object');
+    });
+
+    it('should optimize for web and return boolean', () => {
+      const result = manager.optimizeForWeb();
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should optimize for print and return boolean', () => {
+      const result = manager.optimizeForPrint();
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should support all compression levels', () => {
+      const levels = ['NONE', 'FAST', 'BALANCED', 'BEST'];
+
+      for (const level of levels) {
+        const settings = {
+          level,
+          compress_images: true,
+          compress_streams: true,
+          compress_fonts: true,
+          remove_duplicates: true,
+        };
+        manager.compressDocument(settings);
+      }
+    });
+  });
+
+  describe('CustomAnnotationManager', () => {
+    let manager: CustomAnnotationManager;
+
+    beforeEach(() => {
+      manager = new CustomAnnotationManager();
+    });
+
+    it('should create custom annotation and return ID or null', () => {
+      const props = { color: 'red', opacity: 0.5 };
+      const result = manager.createCustomAnnotation('highlight', props);
+      expect(result === null || typeof result === 'string').toBe(true);
+    });
+
+    it('should modify annotation and return boolean', () => {
+      const props = { color: 'blue' };
+      const result = manager.modifyAnnotation('anno_1', props);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should delete annotation and return boolean', () => {
+      const result = manager.deleteCustomAnnotation('anno_1');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should register annotation type and return boolean', () => {
+      const handler = (e: any) => {};
+      const result = manager.registerAnnotationType('custom_type', handler);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should set annotation visibility and return boolean', () => {
+      const result = manager.setAnnotationVisibility('anno_1', true);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should export annotations and return boolean', () => {
+      const result = manager.exportAnnotations('/output.json');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should import annotations and return boolean', () => {
+      const result = manager.importAnnotations('/input.json');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should apply annotation style and return boolean', () => {
+      const style = { font_size: 12, color: 'red' };
+      const result = manager.applyAnnotationStyle('anno_1', style);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should reply to annotation and return boolean', () => {
+      const result = manager.replyToAnnotation('anno_1', 'This is a reply');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should get annotation replies as array', () => {
+      const replies = manager.getAnnotationReplies('anno_1');
+      expect(Array.isArray(replies)).toBe(true);
+    });
+
+    it('should flatten annotations and return boolean', () => {
+      const result = manager.flattenAnnotations();
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should convert annotations and return boolean', () => {
+      const result = manager.convertAnnotations('xfdf');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should complete annotation lifecycle', () => {
+      // Create
+      const annoId = manager.createCustomAnnotation('note', { text: 'Important' });
+      // Modify
+      if (annoId) {
+        manager.modifyAnnotation(annoId, { color: 'yellow' });
+        // Reply
+        manager.replyToAnnotation(annoId, 'Updated');
+        // Get replies
+        const replies = manager.getAnnotationReplies(annoId);
+        expect(Array.isArray(replies)).toBe(true);
+      }
+    });
+  });
+
+  describe('ContentSecurityManager', () => {
+    let manager: ContentSecurityManager;
+
+    beforeEach(() => {
+      manager = new ContentSecurityManager();
+    });
+
+    it('should set access control and return boolean', () => {
+      const restrictions = { role: 'admin', action: 'read' };
+      const result = manager.setAccessControl('admin_policy', restrictions);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should validate access and return boolean', () => {
+      const result = manager.validateAccess('admin', 'read');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should apply digital rights and return boolean', () => {
+      const rights = { can_print: true, can_copy: false, can_modify: false };
+      const result = manager.applyDigitalRights(rights);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should sanitize content and return boolean', () => {
+      const result = manager.sanitizeContent(true, true);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should detect suspicious content and return array', () => {
+      const results = manager.detectSuspiciousContent();
+      expect(Array.isArray(results)).toBe(true);
+    });
+
+    it('should get access log as array', () => {
+      const log = manager.getAccessLog();
+      expect(Array.isArray(log)).toBe(true);
+    });
+
+    it('should set expiration date and return boolean', () => {
+      const result = manager.setExpirationDate('2025-12-31');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should enable watermarking and return boolean', () => {
+      const result = manager.enableWatermarking('CONFIDENTIAL');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should track document usage and return boolean', () => {
+      const result = manager.trackDocumentUsage(true);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should get security audit as object', () => {
+      const audit = manager.getSecurityAudit();
+      expect(typeof audit).toBe('object');
+    });
+
+    it('should complete security policy enforcement', () => {
+      // Set access control
+      manager.setAccessControl('strict', { role: 'viewer', action: 'read_only' });
+      // Apply rights
+      manager.applyDigitalRights({ can_print: false, can_copy: false });
+      // Enable watermarking
+      manager.enableWatermarking('RESTRICTED');
+      // Sanitize
+      manager.sanitizeContent(true, true);
+      // Get audit
+      const audit = manager.getSecurityAudit();
+      expect(typeof audit).toBe('object');
+    });
+  });
+
+  describe('Phase 8 Integration Tests', () => {
+    it('should complete document protection workflow', () => {
+      const eventMgr = new EventManager();
+      const encryptionMgr = new EncryptionManager();
+      const securityMgr = new ContentSecurityManager();
+
+      // Register event listeners
+      eventMgr.addEventListener('PROCESSING_STARTED', (e: any) => {
+        console.log('Started');
+      });
+
+      // Set up encryption
+      const settings = {
+        algorithm: 'AES_256',
+        user_password: 'user',
+        owner_password: 'owner',
+        allow_printing: true,
+        allow_copying: false,
+        allow_modification: false,
+      };
+      encryptionMgr.encryptDocument(settings);
+
+      // Apply security
+      securityMgr.setAccessControl('restricted', { action: 'read_only' });
+      securityMgr.enableWatermarking('CONFIDENTIAL');
+    });
+
+    it('should complete document optimization workflow', () => {
+      const compressionMgr = new CompressionManager();
+      const annotationMgr = new CustomAnnotationManager();
+      const securityMgr = new ContentSecurityManager();
+
+      // Compress
+      const settings = {
+        level: 'BALANCED',
+        compress_images: true,
+        compress_streams: true,
+        compress_fonts: true,
+        remove_duplicates: true,
+      };
+      compressionMgr.compressDocument(settings);
+
+      // Manage annotations
+      const annoId = annotationMgr.createCustomAnnotation('note', { text: 'Optimized' });
+
+      // Secure
+      securityMgr.sanitizeContent(true, true);
+    });
+  });
+});