Added mocking to test to avoid API calls where possible

functions/writer_agent.py

@@ -187,7 +187,8 @@ def _write_projects_section(project_repos: list, job_call: dict) -> str:
         },
         {
             'role': 'user',
-            'content': f'JOB CALL\n{json.dumps(job_call)}\n\nREPOSITORIES\n{json.dumps(project_repos)}'
+            'content': (f'JOB CALL\n{json.dumps(job_call)}\n\n' + 
+                f'REPOSITORIES\n{json.dumps(project_repos)}')
         }
     ]
 
@@ -206,4 +207,4 @@ def _write_projects_section(project_repos: list, job_call: dict) -> str:
     if response is not None:
         response = response.choices[0].message.content
 
-    return response
+    return response

tests/test_gradio.py

@@ -22,24 +22,45 @@ class TestProcessInputs(unittest.TestCase):
             self.skipTest(f"Test PDF file not found: {test_pdf_path}")
 
         with patch('functions.gradio.extract_text') 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_job_call, \
+             patch('functions.gradio.write_resume') as mock_write_resume:
 
             mock_extract.return_value = {"test": "data"}
             mock_github.return_value = [{"name": "test-repo"}]
+            mock_job_call.return_value = {"title": "Software Engineer", "requirements": ["Python"]}
+            mock_write_resume.return_value = "# Generated Resume\n\nTest resume content"
 
             result = gradio.process_inputs(
                 linkedin_pdf_path=str(test_pdf_path),
                 github_username="testuser",
-                job_post_text="Software engineer position",
-                user_instructions="Custom instructions"
+                job_post_text="Software engineer position"
             )
 
-            # Function currently returns empty string
-            self.assertEqual(result, "")
+            # Verify all functions were called
+            mock_extract.assert_called_once_with(str(test_pdf_path))
+            mock_github.assert_called_once_with("testuser")
+            mock_job_call.assert_called_once_with("Software engineer position")
+            mock_write_resume.assert_called_once_with(
+                {"test": "data"},
+                [{"name": "test-repo"}],
+                {"title": "Software Engineer", "requirements": ["Python"]}
+            )
+
+            # Function should return the generated resume
+            self.assertEqual(result, "# Generated Resume\n\nTest resume content")
 
+    @patch('functions.gradio.write_resume')
+    @patch('functions.gradio.summarize_job_call')
     @patch('functions.gradio.extract_text')
     @patch('functions.gradio.get_github_repositories')
-    def test_process_inputs_with_pdf_path_mocked(self, mock_github, mock_extract):
+    def test_process_inputs_with_pdf_path_mocked(
+        self,
+        mock_github,
+        mock_extract,
+        mock_job_call,
+        mock_write_resume
+    ):
         """Test process_inputs with a PDF file path (mocked for controlled testing)."""
 
         # Mock successful LinkedIn text extraction
@@ -49,12 +70,16 @@ class TestProcessInputs(unittest.TestCase):
             "experience": "Software Engineer at Company"
         }
         mock_github.return_value = [{"name": "test-repo"}]
+        mock_job_call.return_value = {
+            "title": "Software Engineer",
+            "requirements": ["Python", "JavaScript"]
+        }
+        mock_write_resume.return_value = "# John Doe\n\n## Summary\nExperienced software engineer"
 
         result = gradio.process_inputs(
             linkedin_pdf_path="/path/to/resume.pdf",
             github_username="testuser",
-            job_post_text="Software engineer position",
-            user_instructions="Custom instructions"
+            job_post_text="Software engineer position"
         )
 
         # Verify extract_text was called with the correct path
@@ -63,125 +88,287 @@ class TestProcessInputs(unittest.TestCase):
         # Verify get_github_repositories was called with username
         mock_github.assert_called_once_with("testuser")
 
-        # Function currently returns empty string
-        self.assertEqual(result, "")
+        # Verify job post was processed
+        mock_job_call.assert_called_once_with("Software engineer position")
+
+        # Verify resume generation was called with correct arguments
+        mock_write_resume.assert_called_once()
 
+        # Function should return the generated resume content
+        self.assertEqual(result, "# John Doe\n\n## Summary\nExperienced software engineer")
+
+    @patch('functions.gradio.write_resume')
+    @patch('functions.gradio.summarize_job_call')
     @patch('functions.gradio.extract_text')
     @patch('functions.gradio.get_github_repositories')
-    def test_process_inputs_extraction_failure(self, mock_github, mock_extract):
+    def test_process_inputs_extraction_failure(
+        self, mock_github,
+        mock_extract,
+        mock_job_call,
+        mock_write_resume
+    ):
         """Test process_inputs when LinkedIn extraction fails."""
 
         # Mock failed LinkedIn text extraction
         mock_extract.return_value = None
         mock_github.return_value = None
+        mock_job_call.return_value = None
 
         result = gradio.process_inputs(
             linkedin_pdf_path="/path/to/resume.pdf",
             github_username="testuser",
-            job_post_text="Software engineer position",
-            user_instructions="Custom instructions"
+            job_post_text="Software engineer position"
         )
 
         # Verify extract_text was called
         mock_extract.assert_called_once_with("/path/to/resume.pdf")
         mock_github.assert_called_once_with("testuser")
+        mock_job_call.assert_called_once_with("Software engineer position")
+
+        # write_resume should NOT be called when data is missing
+        mock_write_resume.assert_not_called()
 
-        # Function currently returns empty string
+        # Function should return empty string when processing fails
         self.assertEqual(result, "")
 
+    @patch('functions.gradio.write_resume')
+    @patch('functions.gradio.summarize_job_call')
     @patch('functions.gradio.extract_text')
     @patch('functions.gradio.get_github_repositories')
-    def test_process_inputs_no_pdf_path(self, mock_github, mock_extract):
+    def test_process_inputs_no_pdf_path(
+        self,
+        mock_github,
+        mock_extract,
+        mock_job_call,
+        mock_write_resume
+    ):
         """Test process_inputs with no PDF path provided."""
+
         mock_extract.return_value = None
         mock_github.return_value = []
+        mock_job_call.return_value = {"title": "Software Engineer"}
 
         result = gradio.process_inputs(
             linkedin_pdf_path=None,
             github_username="testuser",
-            job_post_text="Software engineer position",
-            user_instructions="Custom instructions"
+            job_post_text="Software engineer position"
         )
 
         # extract_text should be called with None
         mock_extract.assert_called_once_with(None)
         mock_github.assert_called_once_with("testuser")
+        mock_job_call.assert_called_once_with("Software engineer position")
 
-        # Function currently returns empty string
+        # write_resume should NOT be called when LinkedIn data is missing
+        mock_write_resume.assert_not_called()
+
+        # Function should return empty string when data is insufficient
         self.assertEqual(result, "")
 
+    @patch('functions.gradio.write_resume')
+    @patch('functions.gradio.summarize_job_call')
     @patch('functions.gradio.extract_text')
     @patch('functions.gradio.get_github_repositories')
-    def test_process_inputs_with_long_job_post(self, mock_github, mock_extract):
+    def test_process_inputs_with_long_job_post(
+        self,
+        mock_github,
+        mock_extract,
+        mock_job_call,
+        mock_write_resume
+    ):
         """Test process_inputs with a long job post text (for logging truncation)."""
 
         mock_extract.return_value = {
             "summary": "Test summary"
         }
         mock_github.return_value = []
+        mock_job_call.return_value = {"title": "Software Engineer", "requirements": ["Python"]}
 
         long_job_post = "This is a very long job posting " * 50  # Make it longer than 100 chars
 
         result = gradio.process_inputs(
             linkedin_pdf_path="/path/to/resume.pdf",
             github_username="testuser",
-            job_post_text=long_job_post,
-            user_instructions="Custom instructions"
+            job_post_text=long_job_post
         )
 
         # Verify extract_text was called
         mock_extract.assert_called_once_with("/path/to/resume.pdf")
         mock_github.assert_called_once_with("testuser")
+        mock_job_call.assert_called_once_with(long_job_post.strip())
+
+        # write_resume should NOT be called when GitHub repos are empty
+        mock_write_resume.assert_not_called()
 
-        # Function currently returns empty string
+        # Function should return empty string when GitHub data is missing
         self.assertEqual(result, "")
 
+    @patch('functions.gradio.write_resume')
+    @patch('functions.gradio.summarize_job_call')
     @patch('functions.gradio.extract_text')
     @patch('functions.gradio.get_github_repositories')
-    def test_process_inputs_github_username_whitespace(self, mock_github, mock_extract):
+    def test_process_inputs_github_username_whitespace(
+        self,
+        mock_github,
+        mock_extract,
+        mock_job_call,
+        mock_write_resume
+    ):
         """Test that github_username is properly stripped of whitespace."""
 
         mock_extract.return_value = None
         mock_github.return_value = []
+        mock_job_call.return_value = {"title": "Engineer"}
 
         result = gradio.process_inputs(
             linkedin_pdf_path=None,
             github_username="  testuser  ",
-            job_post_text="",
-            user_instructions=""
+            job_post_text=""
         )
 
         # Verify get_github_repositories was called with stripped username
         mock_github.assert_called_once_with("testuser")
+        mock_write_resume.assert_not_called()
         self.assertEqual(result, "")
 
+    @patch('functions.gradio.write_resume')
+    @patch('functions.gradio.summarize_job_call')
     @patch('functions.gradio.extract_text')
     @patch('functions.gradio.get_github_repositories')
     @patch('logging.getLogger')
-    def test_logging_calls(self, mock_get_logger, mock_github, mock_extract):
+    def test_logging_calls(
+        self,
+        mock_get_logger,
+        mock_github,
+        mock_extract,
+        mock_job_call,
+        mock_write_resume
+    ):
         """Test that appropriate logging calls are made."""
 
         mock_logger = mock_get_logger.return_value
         mock_extract.return_value = {"test": "data"}
         mock_github.return_value = [{"name": "repo"}]
+        mock_job_call.return_value = {"title": "Engineer"}
+        mock_write_resume.return_value = "# Resume Content"
 
-        gradio.process_inputs(
+        result = gradio.process_inputs(
             linkedin_pdf_path="/path/to/resume.pdf",
             github_username="testuser",
-            job_post_text="Job description here",
-            user_instructions="Custom instructions"
+            job_post_text="Job description here"
         )
 
         # Verify logging calls were made
         mock_logger.info.assert_called()
+        # Verify resume was generated successfully
+        self.assertEqual(result, "# Resume Content")
+
+    @patch('functions.gradio.write_resume')
+    @patch('functions.gradio.summarize_job_call')
+    @patch('functions.gradio.extract_text')
+    @patch('functions.gradio.get_github_repositories')
+    def test_process_inputs_write_resume_exception(
+        self,
+        mock_github,
+        mock_extract,
+        mock_job_call,
+        mock_write_resume
+    ):
+        """Test process_inputs when write_resume raises an exception."""
+
+        mock_extract.return_value = {"test": "data"}
+        mock_github.return_value = [{"name": "repo"}]
+        mock_job_call.return_value = {"title": "Engineer"}
+        mock_write_resume.side_effect = Exception("API Error")
+
+        result = gradio.process_inputs(
+            linkedin_pdf_path="/path/to/resume.pdf",
+            github_username="testuser",
+            job_post_text="Job description here"
+        )
+
+        # Verify all functions were called
+        mock_extract.assert_called_once_with("/path/to/resume.pdf")
+        mock_github.assert_called_once_with("testuser")
+        mock_job_call.assert_called_once_with("Job description here")
+        mock_write_resume.assert_called_once()
+
+        # Function should return empty string when write_resume fails
+        self.assertEqual(result, "")
+
+    @patch('functions.gradio.write_resume')
+    @patch('functions.gradio.summarize_job_call')
+    @patch('functions.gradio.extract_text')
+    @patch('functions.gradio.get_github_repositories')
+    def test_process_inputs_complete_success_flow(
+        self,
+        mock_github,
+        mock_extract,
+        mock_job_call,
+        mock_write_resume
+    ):
+        """Test the complete successful flow with all components working."""
+
+        # Mock all successful responses
+        linkedin_data = {
+            "contact_info": "Jane Doe, [email protected]",
+            "summary": "Senior Python Developer",
+            "experience": "5 years experience in Python development"
+        }
+        github_repos = [
+            {"name": "awesome-python-app", "description": "A Python web application"},
+            {"name": "data-analysis-tool", "description": "Data analysis with pandas"}
+        ]
+        job_data = {
+            "title": "Senior Python Developer",
+            "requirements": ["Python", "Django", "PostgreSQL"],
+            "company": "Tech Corp"
+        }
+        resume_content = (
+            "# Jane Doe\n\n## Experience\n"
+            "Senior Python Developer with 5 years experience..."
+        )
+
+        mock_extract.return_value = linkedin_data
+        mock_github.return_value = github_repos
+        mock_job_call.return_value = job_data
+        mock_write_resume.return_value = resume_content
+
+        result = gradio.process_inputs(
+            linkedin_pdf_path="/path/to/jane_resume.pdf",
+            github_username="jane_dev",
+            job_post_text="We are looking for a Senior Python Developer with Django experience..."
+        )
+
+        # Verify all functions were called with correct arguments
+        mock_extract.assert_called_once_with("/path/to/jane_resume.pdf")
+        mock_github.assert_called_once_with("jane_dev")
+        mock_job_call.assert_called_once_with(
+            "We are looking for a Senior Python Developer with Django experience..."
+        )
+        mock_write_resume.assert_called_once_with(linkedin_data, github_repos, job_data)
+
+        # Verify the complete resume is returned
+        self.assertEqual(result, resume_content)
+        self.assertIn("Jane Doe", result)
+        self.assertIn("Senior Python Developer", result)
 
+    @patch('functions.gradio.write_resume')
+    @patch('functions.gradio.summarize_job_call')
     @patch('functions.gradio.extract_text')
     @patch('functions.gradio.get_github_repositories')
-    def test_process_inputs_none_github_username(self, mock_github, mock_extract):
+    def test_process_inputs_none_github_username(
+        self,
+        mock_github,
+        mock_extract,
+        mock_job_call,
+        mock_write_resume
+    ):
         """Test process_inputs with None github_username (should handle gracefully)."""
 
         mock_extract.return_value = None
         mock_github.return_value = None
+        mock_job_call.return_value = None
 
         # This should raise a TypeError due to the bug in gradio.py
         # where it tries to slice job_post_text[:100] when job_post_text is None
@@ -189,8 +376,7 @@ class TestProcessInputs(unittest.TestCase):
             gradio.process_inputs(
                 linkedin_pdf_path=None,
                 github_username=None,
-                job_post_text=None,
-                user_instructions=None
+                job_post_text=None
             )
 
 

tests/test_resumate.py

@@ -19,8 +19,6 @@ class TestResumeGeneration(unittest.TestCase):
         with open('tests/test_data/sample_job.txt', 'r', encoding='utf-8') as f:
             self.job_post_text = f.read().strip()
 
-        self.user_instructions = ""
-
         with open('tests/test_data/github_repos.json', 'r', encoding='utf-8') as f:
             self.github_repositories = json.load(f)
 
@@ -38,7 +36,6 @@ class TestResumeGeneration(unittest.TestCase):
             linkedin_pdf_path=self.linkedin_pdf_path,
             github_username=self.github_username,
             job_post_text=self.job_post_text,
-            user_instructions=self.user_instructions
         )
 
         print(result)