compounding-intelligence/tests/test_quality_gate.py

"""
Tests for quality_gate.py — Knowledge entry quality scoring.
"""

import unittest
from datetime import datetime, timezone, timedelta

import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).parent.parent))

from quality_gate import (
    score_specificity,
    score_actionability,
    score_freshness,
    score_source_quality,
    score_entry,
    filter_entries,
)


class TestScoreSpecificity(unittest.TestCase):
    def test_specific_content_scores_high(self):
        content = "Run `python3 deploy.py --env prod` on 2026-04-15. Example: step 1 configure nginx."
        score = score_specificity(content)
        self.assertGreater(score, 0.6)

    def test_vague_content_scores_low(self):
        content = "It generally depends. Various factors might affect this. Basically, it varies."
        score = score_specificity(content)
        self.assertLess(score, 0.5)

    def test_empty_scores_baseline(self):
        score = score_specificity("")
        self.assertAlmostEqual(score, 0.5, delta=0.1)


class TestScoreActionability(unittest.TestCase):
    def test_actionable_content_scores_high(self):
        content = "1. Run `pip install -r requirements.txt`\n2. Execute `python3 train.py`\n3. Verify with `pytest`"
        score = score_actionability(content)
        self.assertGreater(score, 0.6)

    def test_abstract_content_scores_low(self):
        content = "The concept of intelligence is fascinating and multifaceted."
        score = score_actionability(content)
        self.assertLess(score, 0.5)


class TestScoreFreshness(unittest.TestCase):
    def test_recent_timestamp_scores_high(self):
        recent = datetime.now(timezone.utc).isoformat()
        score = score_freshness(recent)
        self.assertGreater(score, 0.9)

    def test_old_timestamp_scores_low(self):
        old = (datetime.now(timezone.utc) - timedelta(days=365)).isoformat()
        score = score_freshness(old)
        self.assertLess(score, 0.2)

    def test_none_returns_baseline(self):
        score = score_freshness(None)
        self.assertEqual(score, 0.5)


class TestScoreSourceQuality(unittest.TestCase):
    def test_claude_scores_high(self):
        self.assertGreater(score_source_quality("claude-sonnet"), 0.85)

    def test_ollama_scores_lower(self):
        self.assertLess(score_source_quality("ollama"), 0.7)

    def test_unknown_returns_default(self):
        self.assertEqual(score_source_quality("unknown"), 0.5)


class TestScoreEntry(unittest.TestCase):
    def test_good_entry_scores_high(self):
        entry = {
            "content": "To deploy: run `kubectl apply -f deployment.yaml`. Verify with `kubectl get pods`.",
            "model": "claude-sonnet",
            "timestamp": datetime.now(timezone.utc).isoformat(),
        }
        score = score_entry(entry)
        self.assertGreater(score, 0.6)

    def test_poor_entry_scores_low(self):
        entry = {
            "content": "It depends. Various things might happen.",
            "model": "unknown",
        }
        score = score_entry(entry)
        self.assertLess(score, 0.5)


class TestFilterEntries(unittest.TestCase):
    def test_filters_low_quality(self):
        entries = [
            {"content": "Run `deploy.py` to fix the issue.", "model": "claude"},
            {"content": "It might work sometimes.", "model": "unknown"},
            {"content": "Configure nginx: step 1 edit nginx.conf", "model": "gpt-4"},
        ]
        filtered = filter_entries(entries, threshold=0.5)
        self.assertGreaterEqual(len(filtered), 2)


if __name__ == "__main__":
    unittest.main()