fixed test

ukr-projects · ukr-projects · commit 421493813a68 · 2025-07-26T23:39:49.000+05:30
diff --git a/tests/test_gemini_ai.py b/tests/test_gemini_ai.py
@@ -14,14 +14,21 @@ class TestGeminiAI(unittest.TestCase):
     @patch("src.app.gemini_ai.genai.configure")
     def setUp(self, mock_configure, mock_model):
         self.api_key = "test_api_key"
+        self.mock_model_instance = MagicMock()
+        mock_model.return_value = self.mock_model_instance
         self.gemini_ai = GeminiAI(api_key=self.api_key)
         self.transcript_text = "This is a test transcript."
-        self.mock_model = mock_model
 
-    @patch("src.app.gemini_ai.genai.GenerativeModel")
-    def test_initialization(self, mock_model):
-        self.assertIsNotNone(self.gemini_ai.model)
+    def test_initialization_with_key(self):
+        with patch("src.app.gemini_ai.genai.configure") as mock_configure, \
+             patch("src.app.gemini_ai.genai.GenerativeModel") as mock_model:
+            
+            gemini_ai = GeminiAI(api_key="test_key")
+            mock_configure.assert_called_once_with(api_key="test_key")
+            mock_model.assert_called_once_with("gemini-1.5-flash")
+            self.assertIsNotNone(gemini_ai.model)
 
+    def test_initialization_without_key(self):
         gemini_ai_no_key = GeminiAI(api_key=None)
         self.assertIsNone(gemini_ai_no_key.model)
 
@@ -32,29 +39,109 @@ def test_is_configured(self):
         self.assertFalse(gemini_ai_no_key.is_configured())
 
     def test_generate_summary_success(self):
-        self.mock_model.return_value.generate_content.return_value = MagicMock(
-            text="This is a summary."
-        )
+        mock_response = MagicMock()
+        mock_response.text = "This is a summary."
+        self.mock_model_instance.generate_content.return_value = mock_response
+        
         summary = self.gemini_ai.generate_summary(self.transcript_text)
         self.assertEqual(summary, "This is a summary.")
+        self.mock_model_instance.generate_content.assert_called_once()
 
     def test_generate_summary_failure(self):
-        self.mock_model.return_value.generate_content.side_effect = Exception(
-            "API Error"
-        )
-
+        self.mock_model_instance.generate_content.side_effect = Exception("API Error")
+        
         summary = self.gemini_ai.generate_summary(self.transcript_text)
         self.assertIn("Error generating summary", summary)
+        self.assertIn("API Error", summary)
+
+    def test_extract_key_quotes_success(self):
+        mock_response = MagicMock()
+        mock_response.text = "These are key quotes."
+        self.mock_model_instance.generate_content.return_value = mock_response
+        
+        quotes = self.gemini_ai.extract_key_quotes(self.transcript_text)
+        self.assertEqual(quotes, "These are key quotes.")
+
+    def test_extract_key_quotes_failure(self):
+        self.mock_model_instance.generate_content.side_effect = Exception("API Error")
+        
+        quotes = self.gemini_ai.extract_key_quotes(self.transcript_text)
+        self.assertIn("Error extracting quotes", quotes)
+
+    def test_create_study_guide_success(self):
+        mock_response = MagicMock()
+        mock_response.text = "This is a study guide."
+        self.mock_model_instance.generate_content.return_value = mock_response
+        
+        study_guide = self.gemini_ai.create_study_guide(self.transcript_text)
+        self.assertEqual(study_guide, "This is a study guide.")
+
+    def test_create_study_guide_failure(self):
+        self.mock_model_instance.generate_content.side_effect = Exception("API Error")
+        
+        study_guide = self.gemini_ai.create_study_guide(self.transcript_text)
+        self.assertIn("Error creating study guide", study_guide)
+
+    def test_generate_qa_success(self):
+        mock_response = MagicMock()
+        mock_response.text = "Q: Test question?\nA: Test answer."
+        self.mock_model_instance.generate_content.return_value = mock_response
+        
+        qa = self.gemini_ai.generate_qa(self.transcript_text)
+        self.assertEqual(qa, "Q: Test question?\nA: Test answer.")
+
+    def test_generate_qa_failure(self):
+        self.mock_model_instance.generate_content.side_effect = Exception("API Error")
+        
+        qa = self.gemini_ai.generate_qa(self.transcript_text)
+        self.assertIn("Error generating Q&A", qa)
+
+    def test_create_flashcards_success(self):
+        mock_response = MagicMock()
+        mock_response.text = "FRONT: Test term\nBACK: Test definition\n---"
+        self.mock_model_instance.generate_content.return_value = mock_response
+        
+        flashcards = self.gemini_ai.create_flashcards(self.transcript_text)
+        self.assertEqual(flashcards, "FRONT: Test term\nBACK: Test definition\n---")
+
+    def test_create_flashcards_failure(self):
+        self.mock_model_instance.generate_content.side_effect = Exception("API Error")
+        
+        flashcards = self.gemini_ai.create_flashcards(self.transcript_text)
+        self.assertIn("Error creating flashcards", flashcards)
+
+    def test_highlight_insights_success(self):
+        mock_response = MagicMock()
+        mock_response.text = "🔍 Key Insights: Test insights"
+        self.mock_model_instance.generate_content.return_value = mock_response
+        
+        insights = self.gemini_ai.highlight_insights(self.transcript_text)
+        self.assertEqual(insights, "🔍 Key Insights: Test insights")
+
+    def test_highlight_insights_failure(self):
+        self.mock_model_instance.generate_content.side_effect = Exception("API Error")
+        
+        insights = self.gemini_ai.highlight_insights(self.transcript_text)
+        self.assertIn("Error extracting insights", insights)
 
     def test_chat_with_transcript_success(self):
-        self.mock_model.return_value.generate_content.return_value = MagicMock(
-            text="This is an answer."
-        )
+        mock_response = MagicMock()
+        mock_response.text = "This is an answer."
+        self.mock_model_instance.generate_content.return_value = mock_response
+        
         answer = self.gemini_ai.chat_with_transcript(
             self.transcript_text, "What is this?"
         )
         self.assertEqual(answer, "This is an answer.")
 
+    def test_chat_with_transcript_failure(self):
+        self.mock_model_instance.generate_content.side_effect = Exception("API Error")
+        
+        answer = self.gemini_ai.chat_with_transcript(
+            self.transcript_text, "What is this?"
+        )
+        self.assertIn("Error in chat", answer)
+
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main()
diff --git a/tests/test_transcript_extractor.py b/tests/test_transcript_extractor.py
@@ -4,7 +4,7 @@
 sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
 
 import unittest
-from unittest.mock import patch, MagicMock
+from unittest.mock import patch, MagicMock, mock_open
 from src.app.transcript_extractor import YouTubeTranscriptExtractor
 
 
@@ -38,23 +38,32 @@ def test_get_transcript_youtube_api_failure(self, mock_api):
         transcript = self.extractor.get_transcript_youtube_api("dQw4w9WgXcQ")
         self.assertIsNone(transcript)
 
+    @patch("src.app.transcript_extractor.tempfile.TemporaryDirectory")
+    @patch("src.app.transcript_extractor.os.listdir")
+    @patch("builtins.open", new_callable=mock_open, read_data="WEBVTT\n\n00:00:00.000 --> 00:00:01.000\nhello from ytdlp")
     @patch("src.app.transcript_extractor.yt_dlp")
-    def test_get_transcript_ytdlp_success(self, mock_ytdlp):
+    def test_get_transcript_ytdlp_success(self, mock_ytdlp, mock_file, mock_listdir, mock_tempdir):
+        # Mock the temporary directory
+        mock_temp_path = "/tmp/test"
+        mock_tempdir.return_value.__enter__.return_value = mock_temp_path
+        
+        # Mock the yt-dlp instance
         mock_ydl_instance = MagicMock()
         mock_ydl_instance.extract_info.return_value = {
-            "subtitles": {"en": [{"ext": "vtt", "url": "..."}]}
+            "title": "Test Video",
+            "duration": 60,
+            "subtitles": {},
+            "automatic_captions": {}
         }
         mock_ytdlp.YoutubeDL.return_value.__enter__.return_value = mock_ydl_instance
-
-        with patch.object(
-            self.extractor,
-            "_process_ytdlp_subtitles",
-            return_value=[{"text": "hello from ytdlp"}],
-        ):
-            transcript = self.extractor.get_transcript_ytdlp("dQw4w9WgXcQ")
-            self.assertIsNotNone(transcript)
-            if transcript:
-                self.assertEqual(transcript[0]["text"], "hello from ytdlp")
+        
+        # Mock file listing to return a VTT file
+        mock_listdir.return_value = ["test_video.en.vtt"]
+        
+        transcript = self.extractor.get_transcript_ytdlp("dQw4w9WgXcQ")
+        self.assertIsNotNone(transcript)
+        if transcript:
+            self.assertEqual(transcript[0]["text"], "hello from ytdlp")
 
     @patch("src.app.transcript_extractor.yt_dlp")
     def test_get_transcript_ytdlp_failure(self, mock_ytdlp):
@@ -94,6 +103,50 @@ def test_extract_transcript_fallback_to_ytdlp(self, mock_ytdlp, mock_api):
         self.assertIsNotNone(transcript)
         self.assertIn("Success using yt-dlp", status)
 
+    def test_parse_vtt_content(self):
+        vtt_content = """WEBVTT
+
+00:00:00.000 --> 00:00:01.000
+hello world
+
+00:00:01.000 --> 00:00:02.000
+this is a test"""
+        
+        transcript = self.extractor._parse_vtt_content(vtt_content)
+        self.assertEqual(len(transcript), 2)
+        self.assertEqual(transcript[0]["text"], "hello world")
+        self.assertEqual(transcript[0]["start"], 0.0)
+        self.assertEqual(transcript[1]["text"], "this is a test")
+        self.assertEqual(transcript[1]["start"], 1.0)
+
+    def test_parse_srt_content(self):
+        srt_content = """1
+00:00:00,000 --> 00:00:01,000
+hello world
+
+2
+00:00:01,000 --> 00:00:02,000
+this is a test"""
+        
+        transcript = self.extractor._parse_srt_content(srt_content)
+        self.assertEqual(len(transcript), 2)
+        self.assertEqual(transcript[0]["text"], "hello world")
+        self.assertEqual(transcript[0]["start"], 0.0)
+        self.assertEqual(transcript[1]["text"], "this is a test")
+        self.assertEqual(transcript[1]["start"], 1.0)
+
+    def test_parse_timestamp(self):
+        # Test VTT timestamp parsing
+        self.assertEqual(self.extractor._parse_timestamp("00:00:01.500"), 1.5)
+        self.assertEqual(self.extractor._parse_timestamp("00:01:30.250"), 90.25)
+        self.assertEqual(self.extractor._parse_timestamp("01:00:00.000"), 3600.0)
+
+    def test_parse_srt_timestamp(self):
+        # Test SRT timestamp parsing
+        self.assertEqual(self.extractor._parse_srt_timestamp("00:00:01,500"), 1.5)
+        self.assertEqual(self.extractor._parse_srt_timestamp("00:01:30,250"), 90.25)
+        self.assertEqual(self.extractor._parse_srt_timestamp("01:00:00,000"), 3600.0)
+
 
 if __name__ == "__main__":
-    unittest.main()
+    unittest.main()
