| """ |
| PhD Research OS — Taxonomy Tests |
| ================================== |
| Tests for the Quantum-Bio V2 taxonomy, domain management, and confidence scoring. |
| """ |
|
|
| import os |
| import sys |
| import json |
| import pytest |
|
|
| sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) |
|
|
| from phd_research_os.taxonomy import ( |
| TaxonomyManager, STUDY_TYPE_WEIGHTS, ALLOWED_STUDY_TYPES, |
| TAXONOMY_VERSION, PIPELINE_VERSION, LEGACY_TO_V2_MAP |
| ) |
| from phd_research_os.db import init_db, get_db, create_claim, create_source, to_fixed, from_fixed |
|
|
| TEST_DB = "test_taxonomy.db" |
|
|
|
|
| @pytest.fixture(autouse=True) |
| def setup_teardown(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| |
| conn = get_db(TEST_DB) |
| create_claim(conn, "Test claim", "Fact", 0.85, |
| study_type="primary_experimental", evidence_strength=0.9) |
| create_source(conn, "10.1234/test", "Test Paper", study_type="Simulation") |
| conn.close() |
| yield |
| for suffix in ["", "-wal", "-shm"]: |
| p = TEST_DB + suffix |
| if os.path.exists(p): |
| os.remove(p) |
|
|
|
|
| |
| |
| |
|
|
| def test_8_study_types_defined(): |
| assert len(ALLOWED_STUDY_TYPES) == 8 |
|
|
| def test_weights_are_fixed_point(): |
| for st, weight in STUDY_TYPE_WEIGHTS.items(): |
| assert isinstance(weight, int), f"{st} weight should be int (fixed-point)" |
| assert 0 <= weight <= 1000, f"{st} weight {weight} out of range" |
|
|
| def test_in_vivo_highest(): |
| assert STUDY_TYPE_WEIGHTS["in_vivo"] == 1000 |
|
|
| def test_perspective_lowest(): |
| assert STUDY_TYPE_WEIGHTS["perspective"] == 200 |
|
|
| def test_simulation_split(): |
| """First-principles > phenomenological.""" |
| assert STUDY_TYPE_WEIGHTS["first_principles_simulation"] > STUDY_TYPE_WEIGHTS["phenomenological_simulation"] |
|
|
|
|
| |
| |
| |
|
|
| def test_normalize_legacy_types(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| assert tm.normalize_study_type("PrimaryExperimental") == "direct_physical_measurement" |
| assert tm.normalize_study_type("InVitro") == "in_vitro" |
| assert tm.normalize_study_type("Simulation") == "phenomenological_simulation" |
| assert tm.normalize_study_type("Review") == "review" |
|
|
| def test_normalize_aliases(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| assert tm.normalize_study_type("clinical_trial") == "in_vivo" |
| assert tm.normalize_study_type("meta-analysis") == "review" |
| assert tm.normalize_study_type("case_study") == "perspective" |
|
|
| def test_normalize_v2_identity(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| for st in ALLOWED_STUDY_TYPES: |
| assert tm.normalize_study_type(st) == st |
|
|
| def test_normalize_case_insensitive(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| assert tm.normalize_study_type("IN_VIVO") == "in_vivo" |
| assert tm.normalize_study_type("Mathematical_Proof") == "mathematical_proof" |
|
|
|
|
| |
| |
| |
|
|
| def test_confidence_max(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| result = tm.score_confidence(1.0, "in_vivo", 1, True) |
| assert result["confidence"] == 1.0 |
|
|
| def test_confidence_formula(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| result = tm.score_confidence(0.8, "in_vitro", 2, True) |
| |
| assert 0.57 <= result["confidence"] <= 0.58 |
|
|
| def test_confidence_incomplete_penalty(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| complete = tm.score_confidence(0.9, "in_vivo", 1, True) |
| incomplete = tm.score_confidence(0.9, "in_vivo", 1, False) |
| assert incomplete["confidence"] < complete["confidence"] |
| assert incomplete["completeness_penalty"] == 0.7 |
|
|
| def test_confidence_taxonomy_version_tag(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| result = tm.score_confidence(0.5, "review", 3, True) |
| assert result["taxonomy_version"] == TAXONOMY_VERSION |
|
|
| def test_confidence_perspective_low(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| result = tm.score_confidence(1.0, "perspective", 1, True) |
| assert result["confidence"] == 0.2 |
|
|
|
|
| |
| |
| |
|
|
| def test_default_domains_seeded(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| domains = tm.list_domains() |
| domain_ids = [d["domain_id"] for d in domains] |
| assert "quantum_bio" in domain_ids |
| assert "biosensors" in domain_ids |
| assert "materials_science" in domain_ids |
|
|
| def test_create_custom_domain(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| tm.create_domain("my_field", "My Research Field", "Custom taxonomy") |
| domain = tm.get_domain("my_field") |
| assert domain is not None |
| assert domain["name"] == "My Research Field" |
|
|
| def test_add_custom_study_type(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| tm.create_domain("test_domain", "Test", "Test domain") |
| tm.add_study_type("test_domain", "custom_assay", 0.75, "A custom assay type") |
| |
| domain = tm.get_domain("test_domain") |
| assert "custom_assay" in domain["custom_study_types"] |
| assert domain["custom_study_types"]["custom_assay"]["weight"] == 750 |
|
|
| def test_custom_type_affects_scoring(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| tm.create_domain("test_scoring", "Test", "Test") |
| tm.add_study_type("test_scoring", "ultra_precise", 0.99, "Ultra-precise measurement") |
| |
| result = tm.score_confidence(1.0, "ultra_precise", 1, True, domain_id="test_scoring") |
| assert 0.98 <= result["confidence"] <= 1.0 |
|
|
| def test_remove_study_type(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| tm.create_domain("rm_test", "Test", "Test") |
| tm.add_study_type("rm_test", "temp_type", 0.5, "Temporary") |
| assert tm.remove_study_type("rm_test", "temp_type") |
| |
| domain = tm.get_domain("rm_test") |
| assert "temp_type" not in domain["custom_study_types"] |
|
|
| def test_cannot_delete_base_taxonomy(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| assert not tm.delete_domain("quantum_bio") |
|
|
| def test_soft_delete_domain(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| tm.create_domain("deletable", "Deletable", "Will be deleted") |
| assert tm.delete_domain("deletable") |
| |
| active = tm.list_domains(active_only=True) |
| assert not any(d["domain_id"] == "deletable" for d in active) |
| |
| all_domains = tm.list_domains(active_only=False) |
| assert any(d["domain_id"] == "deletable" for d in all_domains) |
|
|
|
|
| |
| |
| |
|
|
| def test_migration_idempotent(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| result1 = tm.migrate_to_v2() |
| result2 = tm.migrate_to_v2() |
| assert result2["already_migrated"] |
|
|
| def test_migration_normalizes_types(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| result = tm.migrate_to_v2() |
| |
| conn = get_db(TEST_DB) |
| claims = conn.execute("SELECT study_type FROM claims WHERE study_type IS NOT NULL").fetchall() |
| conn.close() |
| |
| for claim in claims: |
| st = dict(claim).get("study_type", "") |
| if st: |
| assert st in ALLOWED_STUDY_TYPES or st in ["primary_experimental"], f"Unexpected type: {st}" |
|
|
| def test_rollback(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| tm.migrate_to_v2() |
| result = tm.rollback_to_v1() |
| assert result["rows_reverted"] >= 0 |
| assert not result["errors"] |
|
|
|
|
| |
| |
| |
|
|
| def test_audit_log_records_actions(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| tm.create_domain("audit_test", "Audit Test", "Testing audit") |
| |
| log = tm.get_audit_log() |
| assert len(log) >= 1 |
| actions = [e["action"] for e in log] |
| assert "create_domain" in actions |
|
|
|
|
| |
| |
| |
|
|
| def test_cache_key_versioned(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| key1 = tm.generate_cache_key("abc123") |
| key2 = tm.generate_cache_key("abc123") |
| assert key1 == key2 |
|
|
| key3 = tm.generate_cache_key("different_hash") |
| assert key1 != key3 |
|
|
| def test_cache_validation(): |
| tm = TaxonomyManager(db_path=TEST_DB) |
| valid_entry = {"taxonomy_version": TAXONOMY_VERSION, "pipeline_version": PIPELINE_VERSION} |
| assert tm.validate_cache_entry(valid_entry) |
| |
| stale_entry = {"taxonomy_version": "old_v1", "pipeline_version": "1.0.0"} |
| assert not tm.validate_cache_entry(stale_entry) |
|
|
|
|
| if __name__ == "__main__": |
| pytest.main([__file__, "-v"]) |
|
|
