feat: Finalize comprehensive fixes for issues #2-#11 and Copilot review

Implemented robust error handling in encryptpdf.py. Updated CLI with type hints and return codes. comprehensive unit and integration tests. Addressed all Copilot feedback regarding imports and docs.

Author: ambicuity

.github/workflows/ci.yml

@@ -25,11 +25,6 @@ jobs:
         python -m pip install --upgrade pip
         pip install poetry
         poetry install
-    - name: Debug Environment
-      run: |
-        poetry env info
-        poetry show
-        poetry run pip list
     - name: Test with unittest
       run: |
         poetry run coverage run -m unittest discover tests

passifypdf/cli.py

@@ -1,10 +1,13 @@
 import argparse
 
 
-def get_arg_parser():
-    arg_parser = argparse.ArgumentParser(description=("Encrypt a PDF file with a password of your choice."), epilog=("For more information, visit: https://github.com/SUPAIDEAS/passifypdf"))
+def get_arg_parser() -> argparse.ArgumentParser:
+    arg_parser = argparse.ArgumentParser(
+        description="Encrypt a PDF file with a password of your choice.",
+        epilog="For more information, visit: https://github.com/SUPAIDEAS/passifypdf"
+    )
     arg_parser.add_argument("-v", "--version", action="version", version="%(prog)s 1.0")
-    arg_parser.add_argument("-i", "--input", required=True, help="path to the input pdf file")
-    arg_parser.add_argument("-o", "--output", required=True, help="path to the output encrypted pdf file")
-    arg_parser.add_argument("-p", "--passwd", required=True, type=str, help="password to encrypt the pdf file")
+    arg_parser.add_argument("-i", "--input", required=True, help="Path to the input PDF file to be encrypted")
+    arg_parser.add_argument("-o", "--output", required=True, help="Path where the encrypted PDF file will be saved")
+    arg_parser.add_argument("-p", "--passwd", required=True, type=str, help="Password to encrypt the PDF file with")
     return arg_parser

passifypdf/encryptpdf.py

@@ -2,32 +2,68 @@
 from pypdf import PdfReader, PdfWriter
 
 
-def encrypt_pdf(input_pdf, output_pdf, password):
-    reader = PdfReader(input_pdf)
-    writer = PdfWriter()
+import sys
+import os
+from pathlib import Path
+from typing import Union
 
-    # Add all pages from the reader to the writer
-    for page_num in range(len(reader.pages)):
-        writer.add_page(reader.pages[page_num])
+def encrypt_pdf(input_pdf: Union[str, Path], output_pdf: Union[str, Path], password: str) -> None:
+    """
+    Encrypts a PDF file with a password.
 
-    # Encrypt with a password
-    writer.encrypt(password)
+    Args:
+        input_pdf (Union[str, Path]): Path to the input PDF file.
+        output_pdf (Union[str, Path]): Path to the output PDF file.
+        password (str): Password to encrypt the PDF with.
 
-    # Write the encrypted PDF to a new PDF file passed as param
-    with open(output_pdf, "wb") as f:
-        writer.write(f)
+    Raises:
+        FileNotFoundError: If the input PDF file does not exist.
+        Exception: For other errors during processing.
+    """
+    input_path = Path(input_pdf)
+    if not input_path.exists():
+        raise FileNotFoundError(f"Input file '{input_pdf}' not found.")
+    
+    if not input_path.is_file():
+         raise IsADirectoryError(f"Input path '{input_pdf}' is not a file.")
 
+    try:
+        reader = PdfReader(input_path)
+        writer = PdfWriter()
 
-def pipeline(any_thing):
-    return any_thing
+        # Add all pages from the reader to the writer
+        for page in reader.pages:
+            writer.add_page(page)
 
+        # Encrypt with a password
+        writer.encrypt(password)
 
-def main():
+        # Write the encrypted PDF to a new PDF file passed as param
+        with open(output_pdf, "wb") as f:
+            writer.write(f)
+
+    except Exception as e:
+        raise Exception(f"Failed to encrypt PDF: {e}")
+
+
+def main() -> int:
+    """
+    Main function to run the CLI.
+    
+    Returns:
+        int: Exit code (0 for success, 1 for failure).
+    """
     arg_parser = get_arg_parser()
     args = arg_parser.parse_args()
-    encrypt_pdf(args.input, args.output, args.passwd)
-    print(f"Congratulations!\nPDF file encrypted successfully and saved as '{args.output}'")
+    
+    try:
+        encrypt_pdf(args.input, args.output, args.passwd)
+        print(f"Congratulations!\nPDF file encrypted successfully and saved as '{args.output}'")
+        return 0
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
 
 
 if __name__ == "__main__":
-    main()
+    sys.exit(main())

tests/integrationtests/test_encryptpdf_integration.py

@@ -1,8 +1,43 @@
 from unittest import TestCase
 
-from passifypdf.encryptpdf import pipeline
 
 
+
+import os
+from pathlib import Path
+from pypdf import PdfWriter, PdfReader
+from passifypdf.encryptpdf import encrypt_pdf
+
 class TestPdfIntegrationTests(TestCase):
-    def test_pipeline_integration(self):
-        self.assertEqual("awesomePdfProtection-Integration", pipeline("awesomePdfProtection-Integration"))
+    def setUp(self):
+        self.input_pdf = "test_input.pdf"
+        self.output_pdf = "test_output.pdf"
+        self.password = "strongpassword"
+        
+        # Create a dummy PDF
+        writer = PdfWriter()
+        writer.add_blank_page(width=100, height=100)
+        with open(self.input_pdf, "wb") as f:
+            writer.write(f)
+
+    def tearDown(self):
+        # Cleanup files
+        if os.path.exists(self.input_pdf):
+            os.remove(self.input_pdf)
+        if os.path.exists(self.output_pdf):
+            os.remove(self.output_pdf)
+
+    def test_encrypt_pdf_integration(self):
+        # Encrypt the PDF
+        encrypt_pdf(self.input_pdf, self.output_pdf, self.password)
+        
+        # Verify output exists
+        self.assertTrue(os.path.exists(self.output_pdf))
+        
+        # Verify it is encrypted
+        reader = PdfReader(self.output_pdf)
+        self.assertTrue(reader.is_encrypted)
+        
+        # Verify we can decrypt it
+        self.assertTrue(reader.decrypt(self.password))
+        self.assertEqual(len(reader.pages), 1)

tests/test_encryptpdf_example.py

@@ -1,17 +1,20 @@
 from unittest import TestCase
 from unittest.mock import patch, mock_open
-from passifypdf.encryptpdf import pipeline, encrypt_pdf
+from passifypdf.encryptpdf import encrypt_pdf
 
 
 class TestPdfUnitTests(TestCase):
-    def test_pipeline(self):
-        self.assertEqual("awesomePdfProtection-UnitTest", pipeline("awesomePdfProtection-UnitTest"))
 
     @patch('passifypdf.encryptpdf.PdfReader')
     @patch('passifypdf.encryptpdf.PdfWriter')
+    @patch('passifypdf.encryptpdf.Path')  # Mock Path
     @patch('builtins.open', new_callable=mock_open)
-    def test_encrypt_pdf(self, mock_file, mock_writer_cls, mock_reader_cls):
+    def test_encrypt_pdf(self, mock_file, mock_path_cls, mock_writer_cls, mock_reader_cls):
         # Setup mocks
+        mock_path_instance = mock_path_cls.return_value
+        mock_path_instance.exists.return_value = True
+        mock_path_instance.is_file.return_value = True
+
         mock_reader_instance = mock_reader_cls.return_value
         mock_reader_instance.pages = ['page1', 'page2']
 
@@ -20,8 +23,13 @@ def test_encrypt_pdf(self, mock_file, mock_writer_cls, mock_reader_cls):
         # Call the function
         encrypt_pdf("input.pdf", "output.pdf", "secret")
 
-        # Verify PdfReader was called
-        mock_reader_cls.assert_called_with("input.pdf")
+        # Verify Path existence check
+        mock_path_cls.assert_called_with("input.pdf")
+        mock_path_instance.exists.assert_called()
+        mock_path_instance.is_file.assert_called()
+
+        # Verify PdfReader was called with the path object
+        mock_reader_cls.assert_called_with(mock_path_instance)
 
         # Verify pages were added
         self.assertEqual(mock_writer_instance.add_page.call_count, 2)
@@ -34,3 +42,20 @@ def test_encrypt_pdf(self, mock_file, mock_writer_cls, mock_reader_cls):
         # Verify file write
         mock_file.assert_called_with("output.pdf", "wb")
         mock_writer_instance.write.assert_called_with(mock_file())
+
+    @patch('passifypdf.encryptpdf.Path')
+    def test_encrypt_pdf_file_not_found(self, mock_path_cls):
+        mock_path_instance = mock_path_cls.return_value
+        mock_path_instance.exists.return_value = False
+        
+        with self.assertRaises(FileNotFoundError):
+            encrypt_pdf("nonexistent.pdf", "output.pdf", "secret")
+
+    @patch('passifypdf.encryptpdf.Path')
+    def test_encrypt_pdf_is_directory(self, mock_path_cls):
+        mock_path_instance = mock_path_cls.return_value
+        mock_path_instance.exists.return_value = True
+        mock_path_instance.is_file.return_value = False
+        
+        with self.assertRaises(IsADirectoryError):
+            encrypt_pdf("directory", "output.pdf", "secret")