pdf-oxide 0.3.24

package/src/tests/extended-managers.test.ts

@@ -0,0 +1,316 @@
+/**
+ * Comprehensive test suite for Phase 6 Extended Managers.
+ * Tests: DocumentExtendedManager, PerformanceManager, BatchProcessingManager, UtilitiesManager
+ */
+
+import { describe, it, expect, beforeEach } from '@jest/globals';
+
+import DocumentExtendedManager from '../managers/document-extended-manager';
+import PerformanceManager from '../managers/performance-manager';
+import BatchProcessingManager from '../managers/batch-processing-manager';
+import UtilitiesManager from '../managers/utilities-manager';
+
+describe('Phase 6 Extended Managers', () => {
+  describe('DocumentExtendedManager', () => {
+    let manager: DocumentExtendedManager;
+
+    beforeEach(() => {
+      manager = new DocumentExtendedManager();
+    });
+
+    it('should get document title as string or null', () => {
+      const result = manager.getDocumentTitle();
+      expect(result).toBeNull || expect(typeof result).toBe('string');
+    });
+
+    it('should set document title and return boolean', () => {
+      const result = manager.setDocumentTitle('Test Document');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should get document author as string or null', () => {
+      const result = manager.getDocumentAuthor();
+      expect(result).toBeNull || expect(typeof result).toBe('string');
+    });
+
+    it('should set document author and return boolean', () => {
+      const result = manager.setDocumentAuthor('John Doe');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should check if document is encrypted', () => {
+      const result = manager.isDocumentEncrypted();
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should get page count as non-negative integer', () => {
+      const result = manager.getPageCount();
+      expect(typeof result).toBe('number');
+      expect(result).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should get document size as non-negative integer', () => {
+      const result = manager.getDocumentSize();
+      expect(typeof result).toBe('number');
+      expect(result).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should get document metadata as object or null', () => {
+      const result = manager.getDocumentMetadata();
+      expect(result === null || typeof result === 'object').toBe(true);
+    });
+
+    it('should perform title roundtrip in integration', () => {
+      const title = 'Integration Test Document';
+      manager.setDocumentTitle(title);
+      // In real scenario, would retrieve and compare
+    });
+  });
+
+  describe('PerformanceManager', () => {
+    let manager: PerformanceManager;
+
+    beforeEach(() => {
+      manager = new PerformanceManager();
+    });
+
+    it('should start timer and return string ID', () => {
+      const timerId = manager.startTimer('test_operation');
+      expect(typeof timerId).toBe('string');
+      expect(timerId).toContain('test_operation');
+    });
+
+    it('should get metrics as array', () => {
+      const metrics = manager.getMetrics();
+      expect(Array.isArray(metrics)).toBe(true);
+    });
+
+    it('should reset metrics and return boolean', () => {
+      const result = manager.resetMetrics();
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should enable caching and return boolean', () => {
+      const result = manager.enableCaching();
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should disable caching and return boolean', () => {
+      const result = manager.disableCaching();
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should clear cache and return boolean', () => {
+      const result = manager.clearCache();
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should get cache size as non-negative integer', () => {
+      const result = manager.getCacheSize();
+      expect(typeof result).toBe('number');
+      expect(result).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should measure timer performance and complete quickly', async () => {
+      const timerId = manager.startTimer('perf_test');
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      const result = manager.stopTimer(timerId);
+      expect(result).toBeDefined();
+    });
+
+    it('should track memory usage as non-negative integer', () => {
+      const result = manager.getMemoryUsage();
+      expect(typeof result).toBe('number');
+      expect(result).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('BatchProcessingManager', () => {
+    let manager: BatchProcessingManager;
+
+    beforeEach(() => {
+      manager = new BatchProcessingManager();
+    });
+
+    it('should create batch job and return job or null', () => {
+      const job = manager.createBatchJob('job_001', '/path/to/file.pdf', 'extract');
+      // Job can be null or object
+    });
+
+    it('should submit batch job and return boolean', () => {
+      const result = manager.submitBatchJob('job_001');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should get batch job status as string or null', () => {
+      const status = manager.getBatchJobStatus('job_001');
+      expect(status === null || typeof status === 'string').toBe(true);
+    });
+
+    it('should get batch job progress between 0 and 100', () => {
+      const progress = manager.getBatchJobProgress('job_001');
+      expect(typeof progress).toBe('number');
+      expect(progress).toBeGreaterThanOrEqual(0);
+      expect(progress).toBeLessThanOrEqual(100);
+    });
+
+    it('should list batch jobs as array', () => {
+      const jobs = manager.listBatchJobs();
+      expect(Array.isArray(jobs)).toBe(true);
+    });
+
+    it('should clear batch jobs and return non-negative count', () => {
+      const count = manager.clearBatchJobs(true);
+      expect(typeof count).toBe('number');
+      expect(count).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should complete full job lifecycle', () => {
+      // Create
+      const job = manager.createBatchJob('test_job', '/test.pdf', 'process');
+      // Submit
+      manager.submitBatchJob('test_job');
+      // Check status
+      const status = manager.getBatchJobStatus('test_job');
+      // Check progress
+      const progress = manager.getBatchJobProgress('test_job');
+      expect(progress).toBeGreaterThanOrEqual(0);
+    });
+  });
+
+  describe('UtilitiesManager', () => {
+    let manager: UtilitiesManager;
+
+    beforeEach(() => {
+      manager = new UtilitiesManager();
+    });
+
+    it('should validate document and return boolean', () => {
+      const result = manager.validateDocument();
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should get document statistics as object or null', () => {
+      const stats = manager.getDocumentStatistics();
+      expect(stats === null || typeof stats === 'object').toBe(true);
+    });
+
+    it('should remove pages and return boolean', () => {
+      const result = manager.removePages([1, 2, 3]);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should duplicate pages and return boolean', () => {
+      const result = manager.duplicatePages(0, 2);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should add watermark and return boolean', () => {
+      const result = manager.addWatermark('DRAFT', 0.5);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should add page numbers and return boolean', () => {
+      const result = manager.addPageNumbers('Page {n}');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should merge PDFs and return boolean', () => {
+      const result = manager.mergePDFs('/output.pdf', ['/file1.pdf', '/file2.pdf']);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should split PDF and return integer', () => {
+      const result = manager.splitPDF('/output_dir', 10);
+      expect(typeof result).toBe('number');
+    });
+
+    it('should rotate PDF and return boolean', () => {
+      const result = manager.rotatePDF(90, '/output.pdf');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should scale PDF and return boolean', () => {
+      const result = manager.scalePDF(1.5, '/output.pdf');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should reorder pages and return boolean', () => {
+      const result = manager.reorderPages([3, 2, 1, 0]);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should complete document transformation pipeline', () => {
+      // Add watermark
+      manager.addWatermark('CONFIDENTIAL', 0.5);
+      // Add page numbers
+      manager.addPageNumbers('Page {n}');
+      // Could add more transformations
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle empty string title gracefully', () => {
+      const manager = new DocumentExtendedManager();
+      const result = manager.setDocumentTitle('');
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should handle invalid page indices gracefully', () => {
+      const manager = new UtilitiesManager();
+      const result = manager.removePages([-1, 999]);
+      expect(typeof result).toBe('boolean');
+    });
+
+    it('should handle null parameters without crashing', () => {
+      const manager = new UtilitiesManager();
+      expect(() => {
+        manager.addWatermark(null as any, 0.5);
+      }).not.toThrow();
+    });
+  });
+
+  describe('Performance Tests', () => {
+    it('should handle 100 batch jobs in reasonable time', () => {
+      const manager = new BatchProcessingManager();
+      const start = Date.now();
+
+      for (let i = 0; i < 100; i++) {
+        manager.createBatchJob(`job_${i}`, `/file_${i}.pdf`, 'process');
+      }
+
+      const elapsed = Date.now() - start;
+      expect(elapsed).toBeLessThan(1000); // Less than 1 second for 100 jobs
+    });
+
+    it('should have reasonable memory overhead for manager creation', () => {
+      const memBefore = (process.memoryUsage().heapUsed / 1024 / 1024);
+
+      for (let i = 0; i < 10; i++) {
+        new DocumentExtendedManager();
+      }
+
+      const memAfter = (process.memoryUsage().heapUsed / 1024 / 1024);
+      const memUsed = memAfter - memBefore;
+
+      // Memory usage should be reasonable
+      expect(memUsed).toBeLessThan(50); // Less than 50MB for 10 managers
+    });
+
+    it('should handle concurrent timer operations safely', async () => {
+      const manager = new PerformanceManager();
+      const promises: Promise<any>[] = [];
+
+      for (let i = 0; i < 10; i++) {
+        promises.push(
+          new Promise((resolve) => {
+            resolve(manager.startTimer('test'));
+          })
+        );
+      }
+
+      const results = await Promise.all(promises);
+      expect(results.length).toBe(10);
+    });
+  });
+});