added feature to extract all images from the pdf #44

Author: Shebin

.github/workflows/node.js.yml

@@ -97,4 +97,4 @@ jobs:
 
       - name: Enforce coverage thresholds
         run: |
-          npx nyc check-coverage --lines 75 --functions 75 --branches 75 --statements 75
+          npx nyc check-coverage --lines 80 --functions 80 --branches 80 --statements 80

test/image_extraction.test.js

@@ -40,4 +40,39 @@ describe('PDF to Images with images', () => {
             expect(extractedImagePaths).to.have.lengthOf(3);
         });
     });
+
+    describe('Default options', () => {
+        it('should extract images with default options when options not provided', async () => {
+            const extractedImagePaths = await pdf2html.extractImages(pdfImageFilepath);
+            should.exist(extractedImagePaths);
+            expect(extractedImagePaths).to.be.an('array');
+            expect(extractedImagePaths).to.have.lengthOf(3);
+            // Check that images are saved to default directory
+            extractedImagePaths.forEach(imagePath => {
+                expect(imagePath).to.include('/files/image/');
+            });
+        });
+    });
+
+    describe('Error handling', () => {
+        it('should handle non-existent PDF file', async () => {
+            try {
+                await pdf2html.extractImages('/path/to/non-existent.pdf');
+                expect.fail('Should have thrown an error');
+            } catch (error) {
+                should.exist(error);
+                expect(error.message).to.include('not found');
+            }
+        });
+
+        it('should handle invalid PDF buffer', async () => {
+            const invalidBuffer = Buffer.from('This is not a PDF');
+            try {
+                await pdf2html.extractImages(invalidBuffer, { outputDirectory: outputDir });
+                expect.fail('Should have thrown an error');
+            } catch (error) {
+                should.exist(error);
+            }
+        });
+    });
 });

test/test.js

@@ -348,3 +348,140 @@ describe('Buffer vs File Path Consistency', () => {
         expect(metaFromFile).to.deep.equal(metaFromBuffer);
     });
 });
+
+// Internal module tests
+const CommandExecutor = require('../lib/CommandExecutor');
+const { PDFProcessingError } = require('../lib/errors');
+
+describe('CommandExecutor', () => {
+    describe('execute', () => {
+        it('should execute a simple command successfully', async () => {
+            const result = await CommandExecutor.execute('echo', ['hello']);
+            expect(result.trim()).to.equal('hello');
+        });
+
+        it('should handle commands with multiple arguments', async () => {
+            const result = await CommandExecutor.execute('echo', ['hello', 'world']);
+            expect(result.trim()).to.equal('hello world');
+        });
+
+        it('should reject when command exits with non-zero code', async () => {
+            try {
+                await CommandExecutor.execute('sh', ['-c', 'exit 1']);
+                expect.fail('Should have thrown an error');
+            } catch (error) {
+                expect(error).to.be.instanceOf(PDFProcessingError);
+                expect(error.command).to.include('sh -c exit 1');
+                expect(error.exitCode).to.equal(1);
+            }
+        });
+
+        it('should include stderr in error message when command fails', async () => {
+            try {
+                await CommandExecutor.execute('sh', ['-c', 'echo "error message" >&2; exit 1']);
+                expect.fail('Should have thrown an error');
+            } catch (error) {
+                expect(error).to.be.instanceOf(PDFProcessingError);
+                expect(error.message).to.include('error message');
+            }
+        });
+
+        it('should handle spawn errors for non-existent commands', async () => {
+            try {
+                await CommandExecutor.execute('nonexistentcommand123456', ['arg']);
+                expect.fail('Should have thrown an error');
+            } catch (error) {
+                expect(error).to.be.instanceOf(PDFProcessingError);
+                expect(error.message).to.include('Failed to spawn process');
+                expect(error.command).to.include('nonexistentcommand123456');
+            }
+        });
+
+        it('should handle process termination by signal', async () => {
+            // This test simulates a process being killed by a signal
+            try {
+                // Start a long-running process and kill it
+                const promise = CommandExecutor.execute('sh', ['-c', 'sleep 10']);
+                
+                // Give it a moment to start
+                await new Promise(resolve => setTimeout(resolve, 100));
+                
+                // Kill all sleep processes (this is a bit hacky but works for testing)
+                await CommandExecutor.execute('sh', ['-c', 'pkill -9 sleep || true']);
+                
+                await promise;
+                expect.fail('Should have thrown an error');
+            } catch (error) {
+                expect(error).to.be.instanceOf(PDFProcessingError);
+                // The error should mention the signal or non-zero exit
+                expect(error.message).to.match(/Process exited with code|signal/);
+            }
+        });
+
+        it('should capture stdout correctly', async () => {
+            const result = await CommandExecutor.execute('sh', ['-c', 'echo "line1"; echo "line2"']);
+            expect(result).to.include('line1');
+            expect(result).to.include('line2');
+        });
+
+        it('should pass options to spawn', async () => {
+            const result = await CommandExecutor.execute('pwd', [], { cwd: '/tmp' });
+            // On macOS, /tmp is a symlink to /private/tmp
+            expect(result.trim()).to.match(/\/tmp$|\/private\/tmp$/);
+        });
+    });
+});
+
+// Additional internal module tests for coverage
+const FileManager = require('../lib/FileManager');
+const HTMLParser = require('../lib/HTMLParser');
+const ImageProcessor = require('../lib/ImageProcessor');
+
+describe('Internal Modules - Coverage Tests', () => {
+    describe('FileManager', () => {
+        it('should use default .pdf extension when not provided', async () => {
+            const buffer = Buffer.from('test content');
+            const filePath = await FileManager.createTempFileFromBuffer(buffer);
+            
+            expect(filePath).to.include('.pdf');
+            
+            // Clean up
+            if (fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+            }
+        });
+    });
+
+    describe('HTMLParser', () => {
+        it('should use default empty options when not provided', () => {
+            const html = '<html><body><div class="page">Page 1</div><div class="page">Page 2</div></body></html>';
+            const pages = HTMLParser.extractPages(html);
+            
+            expect(pages).to.be.an('array');
+            expect(pages).to.have.length(2);
+            expect(pages[0]).to.include('Page 1');
+            expect(pages[1]).to.include('Page 2');
+        });
+    });
+
+    describe('ImageProcessor', () => {
+        it('should throw error when sharp fails to process image', async () => {
+            // Create a file that's not a valid image
+            const invalidImagePath = path.join(__dirname, 'test-invalid.txt');
+            fs.writeFileSync(invalidImagePath, 'This is not an image');
+            
+            try {
+                await ImageProcessor.resize(invalidImagePath, 100, 100);
+                expect.fail('Should have thrown an error');
+            } catch (error) {
+                expect(error).to.exist;
+                expect(error.message).to.include('Missing output file');
+            } finally {
+                // Clean up
+                if (fs.existsSync(invalidImagePath)) {
+                    fs.unlinkSync(invalidImagePath);
+                }
+            }
+        });
+    });
+});