Updated and cleaned up gradio module unittests

tests/test_gradio.py

@@ -3,285 +3,331 @@ Unit tests for the gradio module.
 """
 
 import unittest
-from unittest.mock import patch, MagicMock, mock_open
-import tempfile
-import os
+from unittest.mock import patch, MagicMock
 from functions import gradio
 
 
 class TestProcessInputs(unittest.TestCase):
     """Test cases for the process_inputs function."""
-    
+
     def test_no_inputs_provided(self):
         """Test when no inputs are provided."""
-        result = gradio.process_inputs(None, "", "", "")
-        
-        self.assertIn("❌ No LinkedIn resume PDF file uploaded", result)
-        self.assertIn("❌ No GitHub profile URL provided", result)
-        self.assertIn("❌ Job post not provided", result)
-        self.assertIn("ℹ️ No additional instructions provided", result)
-        self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
-    
+
+        with patch('functions.gradio.get_github_repositories') as mock_github:
+            mock_github.return_value = {"status": "success", "metadata": {"username": "gperdrizet"}}
+
+            result = gradio.process_inputs(None, "", "", "")
+
+            self.assertIn("❌ No LinkedIn resume PDF file uploaded", result)
+            self.assertIn("✅ Using default GitHub Profile URL", result)
+            self.assertIn("❌ Job post not provided", result)
+            self.assertIn("ℹ️ No additional instructions provided", result)
+            self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
+
     def test_all_inputs_provided_success(self):
         """Test when all inputs are provided and successful."""
+
         # Mock LinkedIn PDF file
         mock_pdf = MagicMock()
         mock_pdf.name = "test_resume.pdf"
-        
+
         # Mock successful extraction results
         mock_linkedin_result = {
             "status": "success",
             "structured_text": {"sections": {}, "llm_formatted": "test content"},
             "metadata": {"filename": "test_resume.pdf"}
         }
-        
+
         mock_github_result = {
             "status": "success",
             "repositories": [{"name": "test-repo"}],
             "metadata": {"username": "testuser"}
         }
-        
+
         with patch('functions.gradio.extract_text_from_linkedin_pdf') as mock_linkedin, \
              patch('functions.gradio.get_github_repositories') as mock_github, \
-             patch('functions.gradio.write_resume') as mock_write_resume:
-            
+             patch('functions.gradio.write_resume') as mock_write_resume, \
+             patch('functions.gradio.summarize_job_call') as mock_summarize: #, \
+             #patch('functions.gradio.shutil.copy2') as mock_copy:
+
             mock_linkedin.return_value = mock_linkedin_result
             mock_github.return_value = mock_github_result
             mock_write_resume.return_value = "Generated resume content"
-            
+            mock_summarize.return_value = "Job summary content\n"
+
             result = gradio.process_inputs(
-                mock_pdf, 
-                "https://github.com/testuser", 
+                mock_pdf,
+                "https://github.com/testuser",
                 "Job posting text here",
                 "Please emphasize technical skills"
             )
-            
-            self.assertIn("✅ LinkedIn Resume PDF uploaded", result)
+
+            self.assertIn("✅ LinkedIn Resume PDF provided", result)
             self.assertIn("✅ Text extraction successful", result)
             self.assertIn("✅ GitHub Profile URL provided", result)
             self.assertIn("✅ GitHub list download successful", result)
             self.assertIn("✅ Job post text provided", result)
+            self.assertIn("✅ Job post summary generated", result)
             self.assertIn("✅ Additional instructions provided", result)
             self.assertIn("✅ Resume generated successfully", result)
-            
+
             # Verify write_resume was called with user instructions
             mock_write_resume.assert_called_with(mock_linkedin_result, "Please emphasize technical skills")
-    
+
     @patch('functions.gradio.extract_text_from_linkedin_pdf')
     @patch('functions.gradio.write_resume')
     def test_linkedin_extraction_failure(self, mock_write_resume, mock_extract):
         """Test LinkedIn PDF extraction failure."""
+
         mock_pdf = MagicMock()
         mock_pdf.name = "test_resume.pdf"
-        
+
         mock_extract.return_value = {
             "status": "error",
             "message": "Failed to read PDF"
         }
         mock_write_resume.return_value = "Generated resume content"
-        
-        result = gradio.process_inputs(mock_pdf, "", "", "")
-        
-        self.assertIn("✅ LinkedIn Resume PDF uploaded", result)
-        self.assertIn("❌ Text extraction failed: Failed to read PDF", result)
-        self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
-        # Verify write_resume was NOT called since extraction failed
-        mock_write_resume.assert_not_called()
-    
+
+        with patch('functions.gradio.get_github_repositories') as mock_github:
+            mock_github.return_value = {"status": "success", "metadata": {"username": "gperdrizet"}}
+
+            result = gradio.process_inputs(mock_pdf, "", "", "")
+
+            self.assertIn("✅ LinkedIn Resume PDF provided", result)
+            self.assertIn("❌ Text extraction failed: Failed to read PDF", result)
+            self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
+
+            # Verify write_resume was NOT called since extraction failed
+            mock_write_resume.assert_not_called()
+
     @patch('functions.gradio.extract_text_from_linkedin_pdf')
     @patch('functions.gradio.write_resume')
     def test_linkedin_extraction_warning(self, mock_write_resume, mock_extract):
         """Test LinkedIn PDF extraction warning."""
+
         mock_pdf = MagicMock()
         mock_pdf.name = "test_resume.pdf"
-        
+
         mock_extract.return_value = {
             "status": "warning",
             "message": "No text found in PDF"
         }
         mock_write_resume.return_value = "Generated resume content"
-        
-        result = gradio.process_inputs(mock_pdf, "", "", "")
-        
-        self.assertIn("✅ LinkedIn Resume PDF uploaded", result)
-        self.assertIn("⚠️  Text extraction: No text found in PDF", result)
-        self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
-        # Verify write_resume was NOT called since extraction had warning status
-        mock_write_resume.assert_not_called()
-    
+
+        with patch('functions.gradio.get_github_repositories') as mock_github:
+            mock_github.return_value = {"status": "success", "metadata": {"username": "gperdrizet"}}
+
+            result = gradio.process_inputs(mock_pdf, "", "", "")
+
+            self.assertIn("✅ LinkedIn Resume PDF provided", result)
+            self.assertIn("⚠️  Text extraction: No text found in PDF", result)
+            self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
+
+            # Verify write_resume was NOT called since extraction had warning status
+            mock_write_resume.assert_not_called()
+
     @patch('functions.gradio.get_github_repositories')
     @patch('functions.gradio.write_resume')
     def test_github_retrieval_failure(self, mock_write_resume, mock_github):
         """Test GitHub repository retrieval failure."""
+
         mock_github.return_value = {
             "status": "error",
             "message": "User not found"
         }
         mock_write_resume.return_value = "Generated resume content"
-        
+
         result = gradio.process_inputs(None, "https://github.com/nonexistent", "", "")
-        
+
         self.assertIn("✅ GitHub Profile URL provided", result)
         self.assertIn("❌ GitHub extraction failed: User not found", result)
         self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
+
         # Verify write_resume was NOT called since no LinkedIn data
         mock_write_resume.assert_not_called()
-    
+
     def test_whitespace_only_inputs(self):
         """Test inputs with only whitespace."""
-        result = gradio.process_inputs(None, "   ", "   ", "   ")
-        
-        self.assertIn("❌ No LinkedIn resume PDF file uploaded", result)
-        self.assertIn("❌ No GitHub profile URL provided", result)
-        self.assertIn("❌ Job post not provided", result)
-        self.assertIn("ℹ️ No additional instructions provided", result)
-        self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
-    
+
+        with patch('functions.gradio.get_github_repositories') as mock_github:
+            mock_github.return_value = {"status": "success", "metadata": {"username": "gperdrizet"}}
+
+            result = gradio.process_inputs(None, "   ", "   ", "   ")
+
+            self.assertIn("❌ No LinkedIn resume PDF file uploaded", result)
+            self.assertIn("✅ Using default GitHub Profile URL", result)
+            self.assertIn("❌ Job post not provided", result)
+            self.assertIn("ℹ️ No additional instructions provided", result)
+            self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
+
     @patch('functions.gradio.write_resume')
-    def test_job_post_with_content(self, mock_write_resume):
+    @patch('functions.gradio.summarize_job_call')
+    def test_job_post_with_content(self, mock_summarize, mock_write_resume):
+
         """Test job post with actual content."""
         job_text = "Software Engineer position at Tech Company"
         mock_write_resume.return_value = "Generated resume content"
-        
-        result = gradio.process_inputs(None, "", job_text, "")
-        
-        self.assertIn("✅ Job post text provided", result)
-        self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
-        # Verify write_resume was NOT called since no LinkedIn data
-        mock_write_resume.assert_not_called()
-    
+        mock_summarize.return_value = "Job summary content\n"
+
+        with patch('functions.gradio.get_github_repositories') as mock_github:
+            mock_github.return_value = {"status": "success", "metadata": {"username": "gperdrizet"}}
+
+            result = gradio.process_inputs(None, "", job_text, "")
+
+            self.assertIn("✅ Job post text provided", result)
+            self.assertIn("✅ Job post summary generated", result)
+            self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
+            # Verify write_resume was NOT called since no LinkedIn data
+            mock_write_resume.assert_not_called()
+
     @patch('functions.gradio.logger')
     @patch('functions.gradio.write_resume')
     def test_logging_calls(self, mock_write_resume, mock_logger):
+
         """Test that appropriate logging calls are made."""
         mock_pdf = MagicMock()
         mock_pdf.name = "test.pdf"
         mock_write_resume.return_value = "Generated resume content"
-        
+
         with patch('functions.gradio.extract_text_from_linkedin_pdf') as mock_extract, \
-             patch('functions.gradio.get_github_repositories') as mock_github:
-            
+             patch('functions.gradio.get_github_repositories') as mock_github, \
+             patch('functions.gradio.summarize_job_call') as mock_summarize:
+
             mock_extract.return_value = {"status": "success"}
             mock_github.return_value = {"status": "success", "metadata": {"username": "test"}}
-            
+            mock_summarize.return_value = "Job summary\n"
+
             gradio.process_inputs(mock_pdf, "https://github.com/test", "job text", "custom instructions")
-            
+
             # Verify logging calls were made
             mock_logger.info.assert_called()
-    
+
     @patch('functions.gradio.write_resume')
     def test_user_instructions_with_content(self, mock_write_resume):
+
         """Test user instructions with actual content."""
         instructions = "Please emphasize leadership skills and highlight remote work experience"
         mock_write_resume.return_value = "Generated resume content"
-        
-        result = gradio.process_inputs(None, "", "", instructions)
-        
-        self.assertIn("✅ Additional instructions provided", result)
-        self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
-        # Verify write_resume was NOT called since no valid extraction result
-        mock_write_resume.assert_not_called()
-    
+
+        with patch('functions.gradio.get_github_repositories') as mock_github:
+            mock_github.return_value = {"status": "success", "metadata": {"username": "gperdrizet"}}
+
+            result = gradio.process_inputs(None, "", "", instructions)
+
+            self.assertIn("✅ Additional instructions provided", result)
+            self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
+            # Verify write_resume was NOT called since no valid extraction result
+            mock_write_resume.assert_not_called()
+
     @patch('functions.gradio.write_resume')
     def test_user_instructions_empty(self, mock_write_resume):
+
         """Test user instructions when empty."""
         mock_write_resume.return_value = "Generated resume content"
-        
-        result = gradio.process_inputs(None, "", "", "")
-        
-        self.assertIn("ℹ️ No additional instructions provided", result)
-        self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
-        # Verify write_resume was NOT called since no valid extraction result
-        mock_write_resume.assert_not_called()
+
+        with patch('functions.gradio.get_github_repositories') as mock_github:
+            mock_github.return_value = {"status": "success", "metadata": {"username": "gperdrizet"}}
+
+            result = gradio.process_inputs(None, "", "", "")
+
+            self.assertIn("ℹ️ No additional instructions provided", result)
+            self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
+            # Verify write_resume was NOT called since no valid extraction result
+            mock_write_resume.assert_not_called()
 
 
 class TestGetProcessedData(unittest.TestCase):
     """Test cases for the get_processed_data function."""
-    
+
     def test_no_inputs(self):
         """Test with no inputs provided."""
+
         result = gradio.get_processed_data(None, "", "", "")
-        
+
         self.assertIsNone(result["linkedin"])
         self.assertIsNone(result["github"])
         self.assertIsNone(result["job_post"])
         self.assertIsNone(result["user_instructions"])
         self.assertEqual(len(result["errors"]), 0)
-    
+
     def test_all_successful_inputs(self):
         """Test with all successful inputs."""
+
         mock_pdf = MagicMock()
         mock_pdf.name = "test.pdf"
-        
+
         mock_linkedin_result = {
             "status": "success",
             "structured_text": {"sections": {}, "llm_formatted": "content"}
         }
-        
+
         mock_github_result = {
             "status": "success",
             "repositories": [{"name": "repo"}],
             "metadata": {"username": "user"}
         }
-        
+
         with patch('functions.gradio.extract_text_from_linkedin_pdf') as mock_linkedin, \
              patch('functions.gradio.get_github_repositories') as mock_github:
-            
+
             mock_linkedin.return_value = mock_linkedin_result
             mock_github.return_value = mock_github_result
-            
+
             result = gradio.get_processed_data(
                 mock_pdf,
                 "https://github.com/user",
                 "Job posting content",
                 "Custom instructions"
             )
-            
+
             self.assertEqual(result["linkedin"], mock_linkedin_result)
             self.assertEqual(result["github"], mock_github_result)
             self.assertEqual(result["job_post"], "Job posting content")
             self.assertEqual(result["user_instructions"], "Custom instructions")
             self.assertEqual(len(result["errors"]), 0)
-    
+
     def test_linkedin_error(self):
         """Test with LinkedIn processing error."""
+
         mock_pdf = MagicMock()
         mock_pdf.name = "test.pdf"
-        
+
         with patch('functions.gradio.extract_text_from_linkedin_pdf') as mock_extract:
             mock_extract.return_value = {
                 "status": "error",
                 "message": "PDF read failed"
             }
-            
+
             result = gradio.get_processed_data(mock_pdf, "", "", "")
-            
+
             self.assertIsNone(result["linkedin"])
             self.assertEqual(len(result["errors"]), 1)
             self.assertIn("LinkedIn: PDF read failed", result["errors"])
-    
+
     def test_github_error(self):
         """Test with GitHub processing error."""
+
         with patch('functions.gradio.get_github_repositories') as mock_github:
             mock_github.return_value = {
                 "status": "error",
                 "message": "User not found"
             }
-            
+
             result = gradio.get_processed_data(None, "https://github.com/invalid", "", "")
-            
+
             self.assertIsNone(result["github"])
             self.assertEqual(len(result["errors"]), 1)
             self.assertIn("GitHub: User not found", result["errors"])
-    
+
     def test_multiple_errors(self):
         """Test with multiple processing errors."""
+
         mock_pdf = MagicMock()
         mock_pdf.name = "test.pdf"
-        
+
         with patch('functions.gradio.extract_text_from_linkedin_pdf') as mock_linkedin, \
              patch('functions.gradio.get_github_repositories') as mock_github:
-            
+
             mock_linkedin.return_value = {
                 "status": "error",
                 "message": "LinkedIn error"
@@ -290,88 +336,93 @@ class TestGetProcessedData(unittest.TestCase):
                 "status": "error",
                 "message": "GitHub error"
             }
-            
+
             result = gradio.get_processed_data(
                 mock_pdf,
                 "https://github.com/user",
                 "",
                 ""
             )
-            
+
             self.assertIsNone(result["linkedin"])
             self.assertIsNone(result["github"])
             self.assertEqual(len(result["errors"]), 2)
             self.assertIn("LinkedIn: LinkedIn error", result["errors"])
             self.assertIn("GitHub: GitHub error", result["errors"])
-    
+
     def test_job_post_whitespace_handling(self):
         """Test job post whitespace handling."""
+
         # Test with leading/trailing whitespace
         result = gradio.get_processed_data(None, "", "  Job content  ", "")
         self.assertEqual(result["job_post"], "Job content")
-        
+
         # Test with only whitespace
         result = gradio.get_processed_data(None, "", "   ", "")
         self.assertIsNone(result["job_post"])
-        
+
         # Test with empty string
         result = gradio.get_processed_data(None, "", "", "")
         self.assertIsNone(result["job_post"])
-    
+
     def test_github_url_whitespace_handling(self):
         """Test GitHub URL whitespace handling."""
+
         with patch('functions.gradio.get_github_repositories') as mock_github:
             mock_github.return_value = {"status": "success", "repositories": []}
-            
+
             # Test with leading/trailing whitespace
-            result = gradio.get_processed_data(None, "  https://github.com/user  ", "", "")
+            _ = gradio.get_processed_data(None, "  https://github.com/user  ", "", "")
             mock_github.assert_called_with("  https://github.com/user  ")
-            
+
             # Test with only whitespace - should not call function
             mock_github.reset_mock()
-            result = gradio.get_processed_data(None, "   ", "", "")
+            _ = gradio.get_processed_data(None, "   ", "", "")
             mock_github.assert_not_called()
-    
+
     def test_data_structure_consistency(self):
         """Test that returned data structure is consistent."""
+
         result = gradio.get_processed_data(None, "", "", "")
-        
+
         # Check all required keys exist
         required_keys = ["linkedin", "github", "job_post", "user_instructions", "errors"]
         for key in required_keys:
             self.assertIn(key, result)
-        
+
         # Check data types
         self.assertIsInstance(result["errors"], list)
-    
+
     @patch('functions.gradio.extract_text_from_linkedin_pdf')
     def test_linkedin_warning_status(self, mock_extract):
         """Test handling of LinkedIn warning status."""
+
         mock_pdf = MagicMock()
         mock_pdf.name = "test.pdf"
-        
+
         mock_extract.return_value = {
             "status": "warning",
             "message": "Some warning"
         }
-        
+
         result = gradio.get_processed_data(mock_pdf, "", "", "")
-        
+
         # Warning status should not be treated as success
         self.assertIsNone(result["linkedin"])
         self.assertEqual(len(result["errors"]), 1)
         self.assertIn("LinkedIn: Some warning", result["errors"])
-    
+
     def test_user_instructions_whitespace_handling(self):
         """Test user instructions whitespace handling."""
+
         # Test with leading/trailing whitespace
         result = gradio.get_processed_data(None, "", "", "  Custom instructions  ")
         self.assertEqual(result["user_instructions"], "Custom instructions")
-        
+
         # Test with only whitespace
         result = gradio.get_processed_data(None, "", "", "   ")
         self.assertIsNone(result["user_instructions"])
-        
+
         # Test with empty string
         result = gradio.get_processed_data(None, "", "", "")
         self.assertIsNone(result["user_instructions"])