mirror of
https://github.com/semantica-agi/semantica.git
synced 2026-08-29 04:26:20 +00:00
KaifAhmad1
58707ff721
- Robust ID extraction in CentralityCalculator, CommunityDetector, and ConnectivityAnalyzer - Support for direct Entity objects and dictionaries as node identifiers - Improved Entity hashability in utils/types.py - Added integration test to verify fix and prevent regression
105 lines
4.7 KiB
Python
105 lines
4.7 KiB
Python
import unittest
|
|
from unittest.mock import MagicMock, patch
|
|
import logging
|
|
from semantica.ontology.ontology_generator import OntologyGenerator
|
|
from semantica.ontology.class_inferrer import ClassInferrer
|
|
from semantica.ontology.naming_conventions import NamingConventions
|
|
from semantica.ontology.property_generator import PropertyGenerator
|
|
|
|
class TestOntologyClasses(unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
# Mock dependencies
|
|
self.mock_logger = MagicMock()
|
|
self.mock_progress_tracker = MagicMock()
|
|
|
|
# Patch get_logger and get_progress_tracker
|
|
self.logger_patcher = patch('semantica.ontology.ontology_generator.get_logger', return_value=self.mock_logger)
|
|
self.tracker_patcher = patch('semantica.ontology.ontology_generator.get_progress_tracker', return_value=self.mock_progress_tracker)
|
|
|
|
self.logger_patcher.start()
|
|
self.tracker_patcher.start()
|
|
|
|
# Patch for other modules as well
|
|
self.logger_patcher_ci = patch('semantica.ontology.class_inferrer.get_logger', return_value=self.mock_logger)
|
|
self.tracker_patcher_ci = patch('semantica.ontology.class_inferrer.get_progress_tracker', return_value=self.mock_progress_tracker)
|
|
self.logger_patcher_ci.start()
|
|
self.tracker_patcher_ci.start()
|
|
|
|
self.logger_patcher_nc = patch('semantica.ontology.naming_conventions.get_logger', return_value=self.mock_logger)
|
|
self.tracker_patcher_nc = patch('semantica.ontology.naming_conventions.get_progress_tracker', return_value=self.mock_progress_tracker)
|
|
self.logger_patcher_nc.start()
|
|
self.tracker_patcher_nc.start()
|
|
|
|
self.logger_patcher_pg = patch('semantica.ontology.property_generator.get_logger', return_value=self.mock_logger)
|
|
self.tracker_patcher_pg = patch('semantica.ontology.property_generator.get_progress_tracker', return_value=self.mock_progress_tracker)
|
|
self.logger_patcher_pg.start()
|
|
self.tracker_patcher_pg.start()
|
|
|
|
def tearDown(self):
|
|
self.logger_patcher.stop()
|
|
self.tracker_patcher.stop()
|
|
self.logger_patcher_ci.stop()
|
|
self.tracker_patcher_ci.stop()
|
|
self.logger_patcher_nc.stop()
|
|
self.tracker_patcher_nc.stop()
|
|
self.logger_patcher_pg.stop()
|
|
self.tracker_patcher_pg.stop()
|
|
|
|
def test_naming_conventions_initialization(self):
|
|
nc = NamingConventions()
|
|
self.assertIsInstance(nc, NamingConventions)
|
|
|
|
def test_class_inferrer_initialization(self):
|
|
ci = ClassInferrer()
|
|
self.assertIsInstance(ci, ClassInferrer)
|
|
self.assertEqual(ci.min_occurrences, 2)
|
|
|
|
def test_ontology_generator_initialization(self):
|
|
og = OntologyGenerator()
|
|
self.assertIsInstance(og, OntologyGenerator)
|
|
self.assertIsInstance(og.class_inferrer, ClassInferrer)
|
|
|
|
def test_naming_conventions_pascal_case(self):
|
|
# We need to mock _is_pascal_case and others or test them if exposed
|
|
# Assuming internal methods are used, let's test public method
|
|
# But we need to see if NamingConventions actually implements logic or calls external NLP tools
|
|
# For now, let's just test instantiation and basic call if possible
|
|
nc = NamingConventions()
|
|
# Mocking internal checks to avoid NLP dependencies if any
|
|
with patch.object(nc, '_is_pascal_case', return_value=True), \
|
|
patch.object(nc, '_is_singular', return_value=True), \
|
|
patch.object(nc, '_is_noun_phrase', return_value=True):
|
|
is_valid, suggestion = nc.validate_class_name("Person")
|
|
self.assertTrue(is_valid)
|
|
|
|
def test_infer_classes_empty(self):
|
|
ci = ClassInferrer()
|
|
classes = ci.infer_classes([])
|
|
self.assertEqual(classes, [])
|
|
|
|
def test_infer_classes_basic(self):
|
|
ci = ClassInferrer()
|
|
# Mocking internal methods of ClassInferrer to avoid complex logic in unit test
|
|
# We assume infer_classes calls some internal logic.
|
|
# Let's try to feed it some data and see what happens, assuming simple logic exists
|
|
|
|
entities = [
|
|
{"type": "Person", "name": "Alice"},
|
|
{"type": "Person", "name": "Bob"},
|
|
{"type": "Organization", "name": "Corp"}
|
|
]
|
|
|
|
# If infer_classes relies on min_occurrences=2, Person should be inferred, Organization might not
|
|
# Ideally we should mock the extraction part if it's complex
|
|
# But let's try to see if it runs
|
|
try:
|
|
classes = ci.infer_classes(entities)
|
|
self.assertIsInstance(classes, list)
|
|
# Depending on implementation, it might return class definitions
|
|
except Exception as e:
|
|
self.fail(f"infer_classes failed: {e}")
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|