adding test files. updating exception messages

Dockerfile

@@ -9,7 +9,7 @@ RUN mkdir -p /app/.cache/huggingface/hub && chmod -R 777 /app/.cache
 
 # Copy dependencies
 COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install -r requirements.txt
 
 # Copy all files
 COPY . .

app/routers/analyze.py

@@ -70,8 +70,8 @@ async def analyze_content(request: AnalyzeRequest):
         return AnalyzeResponse.parse_obj(response_dict)
 
     except Exception as e:
-        logger.error(f"Analysis failed: {str(e)}", exc_info=True)
+        logger.error(f"Analysis failed inside of analyze.py: {str(e)}", exc_info=True)
         raise HTTPException(
             status_code=500,
-            detail=f"Analysis failed: {str(e)}"
+            detail=f"Analysis failed inside of analyze.py: {str(e)}"
         )

mediaunmasked/services/analyzer_service.py

@@ -75,8 +75,8 @@ class AnalyzerService:
             return AnalysisResponse.parse_obj(response_dict)
             
         except Exception as e:
-            logger.error(f"Analysis failed: {str(e)}", exc_info=True)
+            logger.error(f"Analysis failed inside of analyzer_service.py: {str(e)}", exc_info=True)
             raise HTTPException(
                 status_code=500,
-                detail=f"Analysis failed: {str(e)}"
+                detail=f"Analysis failed inside of analyzer_service.py: {str(e)}"
             ) 

scripts/test_scraper.py

@@ -0,0 +1,34 @@
+from mediaunmasked.scrapers.article_scraper import ArticleScraper
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def test_scraper():
+    scraper = ArticleScraper()
+    url = "https://www.channelnewsasia.com/singapore/singapore-mccy-sg-culture-pass-arts-culture-heritage-4951451"
+    
+    logger.info(f"Testing scraper with URL: {url}")
+    
+    try:
+        result = scraper.scrape_article(url)
+        
+        if result:
+            print("\nScraping Successful!")
+            print("-" * 50)
+            print(f"Headline: {result['headline']}")
+            print("-" * 50)
+            print("Content Preview (first 500 chars):")
+            print(result['content'][:500])
+            print("...")
+            print("-" * 50)
+            print(f"Total content length: {len(result['content'])} characters")
+        else:
+            print("Scraping failed - no result returned")
+            
+    except Exception as e:
+        logger.error(f"Error during scraping: {str(e)}", exc_info=True)
+
+if __name__ == "__main__":
+    test_scraper() 

tests/test_bias_analyzer.py

@@ -0,0 +1,42 @@
+import unittest
+from mediaunmasked.analyzers.bias_analyzer import BiasAnalyzer
+import logging
+
+class TestBiasAnalyzer(unittest.TestCase):
+    def setUp(self):
+        self.analyzer = BiasAnalyzer()
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+
+    def test_left_bias(self):
+        """Test detection of left-leaning bias"""
+        text = "Progressive policies have shown success in addressing income inequality and social justice issues. The government's intervention has helped protect workers' rights."
+        
+        result = self.analyzer.analyze(text)
+        
+        self.assertIsNotNone(result)
+        self.assertIn('bias', result)
+        self.assertLess(result['bias_score'], 0)  # Negative score indicates left bias
+        self.logger.info(f"Left bias result: {result}")
+
+    def test_right_bias(self):
+        """Test detection of right-leaning bias"""
+        text = "Free market solutions and deregulation have driven economic growth. Individual responsibility and traditional values remain crucial for society."
+        
+        result = self.analyzer.analyze(text)
+        
+        self.assertIsNotNone(result)
+        self.assertIn('bias', result)
+        self.assertGreater(result['bias_score'], 0)  # Positive score indicates right bias
+        self.logger.info(f"Right bias result: {result}")
+
+    def test_neutral_content(self):
+        """Test detection of neutral content"""
+        text = "The study examined various economic policies and their outcomes. Researchers analyzed data from multiple sources to draw conclusions."
+        
+        result = self.analyzer.analyze(text)
+        
+        self.assertIsNotNone(result)
+        self.assertIn('bias', result)
+        self.assertAlmostEqual(result['bias_score'], 0, delta=0.2)  # Should be close to neutral
+        self.logger.info(f"Neutral content result: {result}") 

tests/test_evidence_analyzer.py

@@ -0,0 +1,45 @@
+import unittest
+from mediaunmasked.analyzers.evidence_analyzer import EvidenceAnalyzer
+import logging
+
+class TestEvidenceAnalyzer(unittest.TestCase):
+    def setUp(self):
+        self.analyzer = EvidenceAnalyzer()
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+
+    def test_well_supported_content(self):
+        """Test content with strong evidence"""
+        text = """According to the WHO study, vaccination rates have increased by 25%. 
+        Research published in Nature shows significant results. The data from multiple 
+        studies indicates a clear trend, as reported in the scientific journal."""
+        
+        result = self.analyzer.analyze(text)
+        
+        self.assertIsNotNone(result)
+        self.assertGreater(result['evidence_based_score'], 70)
+        self.logger.info(f"Well-supported content score: {result}")
+
+    def test_poorly_supported_content(self):
+        """Test content with weak evidence"""
+        text = """Some people say this treatment works wonders. Many believe it's the 
+        best solution available. Sources claim it could be revolutionary."""
+        
+        result = self.analyzer.analyze(text)
+        
+        self.assertIsNotNone(result)
+        self.assertLess(result['evidence_based_score'], 50)
+        self.logger.info(f"Poorly-supported content score: {result}")
+
+    def test_mixed_evidence_content(self):
+        """Test content with mixed evidence quality"""
+        text = """According to recent studies, the treatment shows promise. Some experts 
+        claim it could be effective, while research published in medical journals 
+        indicates more testing is needed."""
+        
+        result = self.analyzer.analyze(text)
+        
+        self.assertIsNotNone(result)
+        self.assertGreater(result['evidence_based_score'], 30)
+        self.assertLess(result['evidence_based_score'], 80)
+        self.logger.info(f"Mixed evidence content score: {result}") 

tests/test_headline_analyzer.py

@@ -0,0 +1,59 @@
+import unittest
+from mediaunmasked.analyzers.headline_analyzer import HeadlineAnalyzer
+import logging
+
+class TestHeadlineAnalyzer(unittest.TestCase):
+    def setUp(self):
+        self.analyzer = HeadlineAnalyzer()
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+
+    def test_matching_headline(self):
+        """Test when headline matches content"""
+        headline = "Climate Change Impact on Global Weather Patterns"
+        content = "Scientists have discovered significant changes in global weather patterns due to climate change. The study shows increasing temperatures are affecting weather systems worldwide."
+        
+        result = self.analyzer.analyze(headline, content)
+        
+        self.assertIsNotNone(result)
+        self.assertIn('headline_vs_content_score', result)
+        self.assertGreater(result['headline_vs_content_score'], 70)  # Should have high score
+        
+        self.logger.info(f"Matching headline score: {result['headline_vs_content_score']}")
+
+    def test_misleading_headline(self):
+        """Test when headline is misleading compared to content"""
+        headline = "Shocking New Diet Guarantees Weight Loss"
+        content = "While some dietary changes may contribute to weight loss, there is no guaranteed method. Studies show sustainable weight loss requires lifestyle changes."
+        
+        result = self.analyzer.analyze(headline, content)
+        
+        self.assertIsNotNone(result)
+        self.assertIn('headline_vs_content_score', result)
+        self.assertLess(result['headline_vs_content_score'], 50)  # Should have low score
+        
+        self.logger.info(f"Misleading headline score: {result['headline_vs_content_score']}")
+
+    def test_empty_inputs(self):
+        """Test handling of empty inputs"""
+        result = self.analyzer.analyze("", "")
+        self.assertIsNotNone(result)
+        self.assertIn('headline_vs_content_score', result) 
+
+    def test_matching_headline(analyzer):
+        headline = "New Study Shows Coffee Reduces Heart Disease Risk"
+        content = "Recent research suggests that coffee may have cardiovascular benefits."
+        
+        result = analyzer.analyze(headline, content)
+        
+        assert result["headline_vs_content_score"] > 30
+        assert result["contradiction_score"] < 0.3
+
+    def test_contradictory_headline(analyzer):
+        headline = "Coffee Increases Heart Disease Risk"
+        content = "Studies show coffee decreases cardiovascular disease risk."
+        
+        result = analyzer.analyze(headline, content)
+        
+        assert result["headline_vs_content_score"] < 30
+        assert result["contradiction_score"] > 0.3 

tests/test_scoring.py

@@ -0,0 +1,53 @@
+import unittest
+from mediaunmasked.analyzers.scoring import MediaScorer
+import logging
+
+class TestMediaScorer(unittest.TestCase):
+    def setUp(self):
+        self.scorer = MediaScorer()
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+
+    def test_high_quality_article(self):
+        """Test scoring of high-quality article"""
+        headline = "New Study Shows Link Between Exercise and Mental Health"
+        content = """According to research published in the Journal of Medicine, regular 
+        exercise significantly improves mental health outcomes. The study, conducted over 
+        two years with 1000 participants, found a 30% reduction in anxiety symptoms among 
+        those who exercised regularly. Dr. Smith, lead researcher, stated that the findings 
+        demonstrate a clear correlation between physical activity and mental wellbeing."""
+        
+        result = self.scorer.calculate_media_score(headline, content)
+        
+        self.assertIsNotNone(result)
+        self.assertGreater(result['media_unmasked_score'], 80)
+        self.assertEqual(result['rating'], 'Trustworthy')
+        self.logger.info(f"High quality article score: {result}")
+
+    def test_biased_article(self):
+        """Test scoring of biased article"""
+        headline = "Government Policies Destroying Our Way of Life"
+        content = """Experts say the radical new policies are ruining everything! 
+        Sources claim this is the worst decision ever made. Many believe this will 
+        lead to disaster. The socialist agenda is clearly destroying our values."""
+        
+        result = self.scorer.calculate_media_score(headline, content)
+        
+        self.assertIsNotNone(result)
+        self.assertLess(result['media_unmasked_score'], 60)
+        self.assertEqual(result['rating'], 'Bias Present')
+        self.logger.info(f"Biased article score: {result}")
+
+    def test_misleading_article(self):
+        """Test scoring of misleading article"""
+        headline = "Miracle Cure Found for All Diseases!"
+        content = """Some people say this amazing discovery cures everything! 
+        You won't believe the shocking results. Everyone knows this is the 
+        breakthrough we've been waiting for!"""
+        
+        result = self.scorer.calculate_media_score(headline, content)
+        
+        self.assertIsNotNone(result)
+        self.assertLess(result['media_unmasked_score'], 50)
+        self.assertEqual(result['rating'], 'Misleading')
+        self.logger.info(f"Misleading article score: {result}") 

tests/test_scraper.py

@@ -0,0 +1,47 @@
+import unittest
+from mediaunmasked.scrapers.article_scraper import ArticleScraper
+import logging
+
+class TestArticleScraper(unittest.TestCase):
+    def setUp(self):
+        self.scraper = ArticleScraper()
+        # Configure logging for tests
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+
+    def test_cna_article(self):
+        """Test scraping a Channel News Asia article"""
+        url = "https://www.channelnewsasia.com/singapore/singapore-mccy-sg-culture-pass-arts-culture-heritage-4951451"
+        result = self.scraper.scrape_article(url)
+        
+        # Log the result
+        self.logger.info("Scraping Result:")
+        self.logger.info(f"Headline: {result.get('headline', 'No headline found')}")
+        self.logger.info(f"Content Preview: {result.get('content', 'No content found')[:200]}...")
+        
+        # Basic assertions
+        self.assertIsNotNone(result)
+        self.assertIn('headline', result)
+        self.assertIn('content', result)
+        self.assertNotEqual(result['headline'], '')
+        self.assertNotEqual(result['content'], '')
+        
+        # Print full result for manual inspection
+        print("\nFull Scraping Result:")
+        print(f"Headline: {result['headline']}")
+        print(f"\nContent Preview (first 500 chars):\n{result['content'][:500]}...")
+
+    def test_invalid_url(self):
+        """Test scraping an invalid URL"""
+        url = "https://invalid.url.that.doesnt.exist"
+        result = self.scraper.scrape_article(url)
+        self.assertIsNone(result)
+
+    def test_empty_url(self):
+        """Test scraping with empty URL"""
+        url = ""
+        result = self.scraper.scrape_article(url)
+        self.assertIsNone(result)
+
+if __name__ == '__main__':
+    unittest.main() 

tests/test_sentiment_analyzer.py

@@ -0,0 +1,40 @@
+import unittest
+from mediaunmasked.analyzers.sentiment_analyzer import SentimentAnalyzer
+import logging
+
+class TestSentimentAnalyzer(unittest.TestCase):
+    def setUp(self):
+        self.analyzer = SentimentAnalyzer()
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+
+    def test_positive_sentiment(self):
+        """Test detection of positive sentiment"""
+        text = "The breakthrough research shows promising results in cancer treatment, bringing hope to millions of patients worldwide."
+        
+        result = self.analyzer.analyze(text)
+        
+        self.assertIsNotNone(result)
+        self.assertEqual(result['sentiment'], 'Positive')
+        self.logger.info(f"Positive sentiment result: {result}")
+
+    def test_negative_sentiment(self):
+        """Test detection of negative sentiment"""
+        text = "The devastating impact of the disaster has left thousands homeless and caused widespread damage to infrastructure."
+        
+        result = self.analyzer.analyze(text)
+        
+        self.assertIsNotNone(result)
+        self.assertEqual(result['sentiment'], 'Negative')
+        self.logger.info(f"Negative sentiment result: {result}")
+
+    def test_manipulative_content(self):
+        """Test detection of manipulative language"""
+        text = "Experts say this shocking new discovery will change everything! Sources claim it's the biggest breakthrough ever, and everyone knows it's true!"
+        
+        result = self.analyzer.analyze(text)
+        
+        self.assertIsNotNone(result)
+        self.assertGreater(result['manipulation_score'], 20)
+        self.assertGreater(len(result['flagged_phrases']), 0)
+        self.logger.info(f"Manipulative content result: {result}") 

tests/unit/test_headline_analyzer.py

@@ -1,24 +0,0 @@
-import pytest
-from src.mediaunmasked.analyzers.headline_analyzer import HeadlineAnalyzer
-
-@pytest.fixture
-def analyzer():
-    return HeadlineAnalyzer()
-
-def test_matching_headline(analyzer):
-    headline = "New Study Shows Coffee Reduces Heart Disease Risk"
-    content = "Recent research suggests that coffee may have cardiovascular benefits."
-    
-    result = analyzer.analyze(headline, content)
-    
-    assert result["headline_vs_content_score"] > 30
-    assert result["contradiction_score"] < 0.3
-
-def test_contradictory_headline(analyzer):
-    headline = "Coffee Increases Heart Disease Risk"
-    content = "Studies show coffee decreases cardiovascular disease risk."
-    
-    result = analyzer.analyze(headline, content)
-    
-    assert result["headline_vs_content_score"] < 30
-    assert result["contradiction_score"] > 0.3