Updated tests

tests/test_github.py

@@ -22,12 +22,12 @@ class TestExtractGitHubUsername(unittest.TestCase):
             ("https://github.com/user123", "user123"),
             ("https://github.com/octocat/Hello-World", "octocat"),
         ]
-        
+
         for url, expected in test_cases:
             with self.subTest(url=url):
                 result = github._extract_github_username(url)
                 self.assertEqual(result, expected)
-    
+
     def test_invalid_github_urls(self):
         """Test handling of invalid GitHub URLs."""
         invalid_urls = [
@@ -38,12 +38,12 @@ class TestExtractGitHubUsername(unittest.TestCase):
             "https://github.com/user-with-very-long-name-that-exceeds-github-limit",
             None
         ]
-        
+
         for url in invalid_urls:
             with self.subTest(url=url):
                 result = github._extract_github_username(url)
                 self.assertIsNone(result)
-    
+
     def test_username_validation(self):
         """Test username format validation."""
         # Valid usernames
@@ -52,7 +52,7 @@ class TestExtractGitHubUsername(unittest.TestCase):
             with self.subTest(username=username):
                 result = github._extract_github_username(f"github.com/{username}")
                 self.assertEqual(result, username)
-        
+
         # Invalid usernames
         invalid_usernames = ["", "a" * 40, "user@name", "user.name"]
         for username in invalid_usernames:
@@ -63,7 +63,7 @@ class TestExtractGitHubUsername(unittest.TestCase):
 
 class TestGetGitHubUserInfo(unittest.TestCase):
     """Test cases for the _get_github_user_info function."""
-    
+
     @patch('requests.get')
     def test_successful_user_info(self, mock_get):
         """Test successful user info retrieval."""
@@ -75,51 +75,51 @@ class TestGetGitHubUserInfo(unittest.TestCase):
             "name": "The Octocat"
         }
         mock_get.return_value = mock_response
-        
+
         result = github._get_github_user_info("octocat")
-        
+
         self.assertEqual(result["status"], "success")
         self.assertIn("data", result)
         self.assertEqual(result["data"]["login"], "octocat")
-    
+
     @patch('requests.get')
     def test_user_not_found(self, mock_get):
         """Test handling of non-existent user."""
         mock_response = MagicMock()
         mock_response.status_code = 404
         mock_get.return_value = mock_response
-        
+
         result = github._get_github_user_info("nonexistentuser")
-        
+
         self.assertEqual(result["status"], "error")
         self.assertIn("not found", result["message"])
-    
+
     @patch('requests.get')
     def test_rate_limit_exceeded(self, mock_get):
         """Test handling of rate limit exceeded."""
         mock_response = MagicMock()
         mock_response.status_code = 403
         mock_get.return_value = mock_response
-        
+
         result = github._get_github_user_info("octocat")
-        
+
         self.assertEqual(result["status"], "error")
         self.assertIn("rate limit", result["message"])
-    
+
     @patch('requests.get')
     def test_network_error(self, mock_get):
         """Test handling of network errors."""
         mock_get.side_effect = requests.RequestException("Connection error")
-        
+
         result = github._get_github_user_info("octocat")
-        
+
         self.assertEqual(result["status"], "error")
         self.assertIn("Network error", result["message"])
 
 
 class TestGetUserRepositories(unittest.TestCase):
     """Test cases for the _get_user_repositories function."""
-    
+
     @patch('requests.get')
     def test_successful_repository_retrieval(self, mock_get):
         """Test successful repository retrieval."""
@@ -135,14 +135,14 @@ class TestGetUserRepositories(unittest.TestCase):
             }
         ]
         mock_get.return_value = mock_response
-        
+
         result = github._get_user_repositories("octocat")
-        
+
         self.assertEqual(result["status"], "success")
         self.assertIn("data", result)
         self.assertEqual(len(result["data"]), 1)
         self.assertEqual(result["data"][0]["name"], "Hello-World")
-    
+
     @patch('requests.get')
     def test_empty_repository_list(self, mock_get):
         """Test handling of empty repository list."""
@@ -150,28 +150,28 @@ class TestGetUserRepositories(unittest.TestCase):
         mock_response.status_code = 200
         mock_response.json.return_value = []
         mock_get.return_value = mock_response
-        
+
         result = github._get_user_repositories("octocat")
-        
+
         self.assertEqual(result["status"], "success")
         self.assertEqual(len(result["data"]), 0)
-    
+
     @patch('requests.get')
     def test_api_error(self, mock_get):
         """Test handling of API errors."""
         mock_response = MagicMock()
         mock_response.status_code = 500
         mock_get.return_value = mock_response
-        
+
         result = github._get_user_repositories("octocat")
-        
+
         self.assertEqual(result["status"], "error")
         self.assertIn("GitHub API error", result["message"])
 
 
 class TestProcessRepositoryData(unittest.TestCase):
     """Test cases for the _process_repository_data function."""
-    
+
     def test_basic_processing(self):
         """Test basic repository data processing."""
         raw_repos = [
@@ -187,9 +187,9 @@ class TestProcessRepositoryData(unittest.TestCase):
                 "fork": False
             }
         ]
-        
+
         result = github._process_repository_data(raw_repos)
-        
+
         self.assertEqual(len(result), 1)
         processed_repo = result[0]
         self.assertEqual(processed_repo["name"], "test-repo")
@@ -198,7 +198,7 @@ class TestProcessRepositoryData(unittest.TestCase):
         self.assertEqual(processed_repo["stars"], 10)
         self.assertEqual(processed_repo["forks"], 5)
         self.assertFalse(processed_repo["is_fork"])
-    
+
     def test_fork_filtering(self):
         """Test filtering of unmodified forks."""
         raw_repos = [
@@ -218,16 +218,16 @@ class TestProcessRepositoryData(unittest.TestCase):
                 "stargazers_count": 3
             }
         ]
-        
+
         result = github._process_repository_data(raw_repos)
-        
+
         # Should include original repo and modified fork, exclude unmodified fork
         self.assertEqual(len(result), 2)
         repo_names = [repo["name"] for repo in result]
         self.assertIn("original-repo", repo_names)
         self.assertIn("modified-fork", repo_names)
         self.assertNotIn("unmodified-fork", repo_names)
-    
+
     def test_missing_fields(self):
         """Test handling of missing fields in repository data."""
         raw_repos = [
@@ -236,9 +236,9 @@ class TestProcessRepositoryData(unittest.TestCase):
                 # Missing most optional fields
             }
         ]
-        
+
         result = github._process_repository_data(raw_repos)
-        
+
         self.assertEqual(len(result), 1)
         processed_repo = result[0]
         self.assertEqual(processed_repo["name"], "minimal-repo")
@@ -250,17 +250,17 @@ class TestProcessRepositoryData(unittest.TestCase):
 
 class TestGetGitHubRepositories(unittest.TestCase):
     """Test cases for the get_github_repositories function."""
-    
+
     def test_empty_url(self):
         """Test handling of empty or None URL."""
         test_cases = [None, "", "   "]
-        
+
         for url in test_cases:
             with self.subTest(url=url):
                 result = github.get_github_repositories(url)
                 self.assertEqual(result["status"], "error")
                 self.assertIn("No GitHub URL provided", result["message"])
-    
+
     @patch('functions.github._get_user_repositories')
     @patch('functions.github._get_github_user_info')
     @patch('functions.github._extract_github_username')
@@ -275,25 +275,25 @@ class TestGetGitHubRepositories(unittest.TestCase):
             "status": "success",
             "data": [{"name": "Hello-World", "fork": False, "stargazers_count": 5}]
         }
-        
+
         result = github.get_github_repositories("https://github.com/octocat")
-        
+
         self.assertEqual(result["status"], "success")
         self.assertIn("repositories", result)
         self.assertIn("metadata", result)
         self.assertEqual(result["metadata"]["username"], "octocat")
-    
+
     def test_invalid_url_format(self):
         """Test handling of invalid URL format."""
         result = github.get_github_repositories("https://gitlab.com/user")
-        
+
         self.assertEqual(result["status"], "error")
         self.assertIn("Invalid GitHub URL format", result["message"])
 
 
 class TestFormatRepositoriesForLLM(unittest.TestCase):
     """Test cases for the format_repositories_for_llm function."""
-    
+
     def test_successful_formatting(self):
         """Test successful formatting of repository data."""
         github_result = {
@@ -315,28 +315,28 @@ class TestFormatRepositoriesForLLM(unittest.TestCase):
                 "profile_url": "https://github.com/testuser"
             }
         }
-        
+
         result = github.format_repositories_for_llm(github_result)
-        
+
         self.assertIn("=== GITHUB REPOSITORIES ===", result)
         self.assertIn("testuser", result)
         self.assertIn("test-repo", result)
         self.assertIn("A test repository", result)
         self.assertIn("Python", result)
         self.assertIn("=== END GITHUB REPOSITORIES ===", result)
-    
+
     def test_error_status(self):
         """Test formatting when there's an error status."""
         github_result = {
             "status": "error",
             "message": "User not found"
         }
-        
+
         result = github.format_repositories_for_llm(github_result)
-        
+
         self.assertIn("could not be retrieved", result)
         self.assertIn("User not found", result)
-    
+
     def test_no_repositories(self):
         """Test formatting when no repositories are found."""
         github_result = {
@@ -344,12 +344,12 @@ class TestFormatRepositoriesForLLM(unittest.TestCase):
             "repositories": [],
             "metadata": {"username": "emptyuser"}
         }
-        
+
         result = github.format_repositories_for_llm(github_result)
-        
+
         self.assertIn("No public repositories found", result)
         self.assertIn("emptyuser", result)
-    
+
     def test_many_repositories_limit(self):
         """Test that formatting limits to 20 repositories."""
         repositories = []
@@ -364,15 +364,15 @@ class TestFormatRepositoriesForLLM(unittest.TestCase):
                 "html_url": f"https://github.com/user/repo-{i}",
                 "topics": []
             })
-        
+
         github_result = {
             "status": "success",
             "repositories": repositories,
             "metadata": {"username": "manyrepos"}
         }
-        
+
         result = github.format_repositories_for_llm(github_result)
-        
+
         # Should mention "and 5 more repositories"
         self.assertIn("and 5 more repositories", result)
         # Should contain the first 20 repos
@@ -384,7 +384,7 @@ class TestFormatRepositoriesForLLM(unittest.TestCase):
 
 class TestGetRepositoryDetails(unittest.TestCase):
     """Test cases for the get_repository_details function."""
-    
+
     def test_invalid_repository_url(self):
         """Test handling of invalid repository URLs."""
         invalid_urls = [
@@ -395,13 +395,13 @@ class TestGetRepositoryDetails(unittest.TestCase):
             "https://github.com/user",
             "not-a-url",
         ]
-        
+
         for url in invalid_urls:
             with self.subTest(url=url):
                 result = github.get_repository_details(url)
                 self.assertEqual(result["status"], "error")
                 self.assertIn("message", result)
-    
+
     @patch('functions.github._get_repository_info')
     @patch('functions.github._extract_repo_info')
     def test_repository_not_found(self, mock_extract, mock_get_info):
@@ -411,12 +411,12 @@ class TestGetRepositoryDetails(unittest.TestCase):
             "status": "error",
             "message": "Repository 'user/nonexistent-repo' not found"
         }
-        
+
         result = github.get_repository_details("https://github.com/user/nonexistent-repo")
-        
+
         self.assertEqual(result["status"], "error")
         self.assertIn("not found", result["message"])
-    
+
     @patch('functions.github._get_repository_contributors')
     @patch('functions.github._get_repository_releases')
     @patch('functions.github._get_repository_contents')
@@ -424,13 +424,13 @@ class TestGetRepositoryDetails(unittest.TestCase):
     @patch('functions.github._get_repository_languages')
     @patch('functions.github._get_repository_info')
     @patch('functions.github._extract_repo_info')
-    def test_successful_repository_details(self, mock_extract, mock_get_info, 
+    def test_successful_repository_details(self, mock_extract, mock_get_info,
                                          mock_languages, mock_readme, mock_contents,
                                          mock_releases, mock_contributors):
         """Test successful repository details retrieval."""
         # Mock URL extraction
         mock_extract.return_value = ("octocat", "Hello-World")
-        
+
         # Mock basic repository info
         mock_get_info.return_value = {
             "status": "success",
@@ -463,23 +463,23 @@ class TestGetRepositoryDetails(unittest.TestCase):
                 "visibility": "public"
             }
         }
-        
+
         # Mock additional data
         mock_languages.return_value = {
             "status": "success",
             "data": {"C": 78.1, "Makefile": 21.9}
         }
-        
+
         mock_readme.return_value = {
             "status": "success",
             "data": "# Hello World\n\nThis is a test repository."
         }
-        
+
         mock_contents.return_value = {
             "status": "success",
             "data": ["README.md", "hello.c", "Makefile"]
         }
-        
+
         mock_releases.return_value = {
             "status": "success",
             "data": [
@@ -492,7 +492,7 @@ class TestGetRepositoryDetails(unittest.TestCase):
                 }
             ]
         }
-        
+
         mock_contributors.return_value = {
             "status": "success",
             "data": [
@@ -504,15 +504,15 @@ class TestGetRepositoryDetails(unittest.TestCase):
                 }
             ]
         }
-        
+
         result = github.get_repository_details("https://github.com/octocat/Hello-World")
-        
+
         # Verify success
         self.assertEqual(result["status"], "success")
         self.assertIn("repository", result)
-        
+
         repo = result["repository"]
-        
+
         # Verify basic info
         self.assertEqual(repo["name"], "Hello-World")
         self.assertEqual(repo["full_name"], "octocat/Hello-World")
@@ -520,7 +520,7 @@ class TestGetRepositoryDetails(unittest.TestCase):
         self.assertEqual(repo["language"], "C")
         self.assertEqual(repo["stars"], 80)
         self.assertEqual(repo["forks"], 9)
-        
+
         # Verify additional data
         self.assertEqual(repo["languages"], {"C": 78.1, "Makefile": 21.9})
         self.assertIn("Hello World", repo["readme"])
@@ -529,13 +529,13 @@ class TestGetRepositoryDetails(unittest.TestCase):
         self.assertEqual(repo["releases"][0]["tag_name"], "v1.0.0")
         self.assertEqual(len(repo["contributors"]), 1)
         self.assertEqual(repo["contributors"][0]["login"], "octocat")
-        
+
         # Verify boolean flags
         self.assertFalse(repo["is_fork"])
         self.assertFalse(repo["is_archived"])
         self.assertFalse(repo["is_private"])
         self.assertTrue(repo["has_issues"])
-    
+
     def test_extract_repo_info_valid_urls(self):
         """Test _extract_repo_info with valid repository URLs."""
         test_cases = [
@@ -545,12 +545,12 @@ class TestGetRepositoryDetails(unittest.TestCase):
             ("github.com/test/example", ("test", "example")),
             ("https://github.com/user/repo/issues", ("user", "repo")),
         ]
-        
+
         for url, expected in test_cases:
             with self.subTest(url=url):
                 result = github._extract_repo_info(url)
                 self.assertEqual(result, expected)
-    
+
     def test_extract_repo_info_invalid_urls(self):
         """Test _extract_repo_info with invalid repository URLs."""
         invalid_urls = [
@@ -560,12 +560,12 @@ class TestGetRepositoryDetails(unittest.TestCase):
             "https://github.com/",
             "not-a-url",
         ]
-        
+
         for url in invalid_urls:
             with self.subTest(url=url):
                 result = github._extract_repo_info(url)
                 self.assertEqual(result, (None, None))
-    
+
     @patch('requests.get')
     def test_get_repository_info_success(self, mock_get):
         """Test _get_repository_info with successful response."""
@@ -576,25 +576,25 @@ class TestGetRepositoryDetails(unittest.TestCase):
             "full_name": "user/test-repo"
         }
         mock_get.return_value = mock_response
-        
+
         result = github._get_repository_info("user", "test-repo")
-        
+
         self.assertEqual(result["status"], "success")
         self.assertIn("data", result)
         self.assertEqual(result["data"]["name"], "test-repo")
-    
+
     @patch('requests.get')
     def test_get_repository_info_not_found(self, mock_get):
         """Test _get_repository_info with 404 response."""
         mock_response = MagicMock()
         mock_response.status_code = 404
         mock_get.return_value = mock_response
-        
+
         result = github._get_repository_info("user", "nonexistent")
-        
+
         self.assertEqual(result["status"], "error")
         self.assertIn("not found", result["message"])
-    
+
     @patch('requests.get')
     def test_get_repository_languages_success(self, mock_get):
         """Test _get_repository_languages with successful response."""
@@ -606,13 +606,13 @@ class TestGetRepositoryDetails(unittest.TestCase):
             "CSS": 25000
         }
         mock_get.return_value = mock_response
-        
+
         result = github._get_repository_languages("user", "repo")
-        
+
         self.assertEqual(result["status"], "success")
         expected_percentages = {"Python": 50.0, "JavaScript": 25.0, "CSS": 25.0}
         self.assertEqual(result["data"], expected_percentages)
-    
+
     @patch('requests.get')
     def test_get_repository_readme_success(self, mock_get):
         """Test _get_repository_readme with successful response."""
@@ -622,19 +622,19 @@ class TestGetRepositoryDetails(unittest.TestCase):
         readme_response.json.return_value = {
             "download_url": "https://raw.githubusercontent.com/user/repo/main/README.md"
         }
-        
+
         # Mock the README content response
         content_response = MagicMock()
         content_response.status_code = 200
         content_response.text = "# Test Repository\n\nThis is a test."
-        
+
         mock_get.side_effect = [readme_response, content_response]
-        
+
         result = github._get_repository_readme("user", "repo")
-        
+
         self.assertEqual(result["status"], "success")
         self.assertIn("Test Repository", result["data"])
-    
+
     @patch('requests.get')
     def test_get_repository_contents_success(self, mock_get):
         """Test _get_repository_contents with successful response."""
@@ -647,9 +647,9 @@ class TestGetRepositoryDetails(unittest.TestCase):
             {"name": "tests", "type": "dir"}
         ]
         mock_get.return_value = mock_response
-        
+
         result = github._get_repository_contents("user", "repo")
-        
+
         self.assertEqual(result["status"], "success")
         expected_structure = ["src/", "tests/", "README.md", "setup.py"]
         self.assertEqual(result["data"], expected_structure)

tests/test_gradio.py

@@ -20,7 +20,8 @@ class TestProcessInputs(unittest.TestCase):
 
             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 job post provided, attempting to use default", result)
+            self.assertIn("✅ Using default job post", result)
             self.assertIn("ℹ️ No additional instructions provided", result)
             self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
 
@@ -159,7 +160,8 @@ class TestProcessInputs(unittest.TestCase):
 
             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 job post provided, attempting to use default", result)
+            self.assertIn("✅ Using default job post", result)
             self.assertIn("ℹ️ No additional instructions provided", result)
             self.assertIn("❌ Cannot generate resume: No valid LinkedIn data extracted", result)
 
@@ -247,8 +249,25 @@ class TestProcessInputs(unittest.TestCase):
 class TestGetProcessedData(unittest.TestCase):
     """Test cases for the get_processed_data function."""
 
-    def test_no_inputs(self):
+    @patch('functions.gradio.load_default_job_call')
+    def test_no_inputs(self, mock_load_default):
         """Test with no inputs provided."""
+        # Mock the default job call loading
+        mock_load_default.return_value = "Default job call content from sample_job.txt"
+
+        result = gradio.get_processed_data(None, "", "", "")
+
+        self.assertIsNone(result["linkedin"])
+        self.assertIsNone(result["github"])
+        self.assertEqual(result["job_post"], "Default job call content from sample_job.txt")
+        self.assertIsNone(result["user_instructions"])
+        self.assertEqual(len(result["errors"]), 0)
+
+    @patch('functions.gradio.load_default_job_call')
+    def test_no_inputs_no_default_job(self, mock_load_default):
+        """Test with no inputs provided and no default job available."""
+        # Mock the default job call loading to return None
+        mock_load_default.return_value = None
 
         result = gradio.get_processed_data(None, "", "", "")
 
@@ -358,20 +377,23 @@ class TestGetProcessedData(unittest.TestCase):
             self.assertIn("LinkedIn: LinkedIn error", result["errors"])
             self.assertIn("GitHub: GitHub error", result["errors"])
 
-    def test_job_post_whitespace_handling(self):
+    @patch('functions.gradio.load_default_job_call')
+    def test_job_post_whitespace_handling(self, mock_load_default):
         """Test job post whitespace handling."""
+        # Mock the default job call loading
+        mock_load_default.return_value = "Default job content"
 
         # Test with leading/trailing whitespace
         result = gradio.get_processed_data(None, "", "  Job content  ", "")
         self.assertEqual(result["job_post"], "Job content")
 
-        # Test with only whitespace
+        # Test with only whitespace - should load default
         result = gradio.get_processed_data(None, "", "   ", "")
-        self.assertIsNone(result["job_post"])
+        self.assertEqual(result["job_post"], "Default job content")
 
-        # Test with empty string
+        # Test with empty string - should load default  
         result = gradio.get_processed_data(None, "", "", "")
-        self.assertIsNone(result["job_post"])
+        self.assertEqual(result["job_post"], "Default job content")
 
     def test_github_url_whitespace_handling(self):
         """Test GitHub URL whitespace handling."""