Graph-Native Infrastructure for Context and Accountable AI Systems
Python agent-memoryaiai-governanceai-infrastructureartificial-intelligencecontext-engineeringcontext-graphsdata-engineeringdecision-intelligencedeveloper-toolsexplainable-aigenerative-aigraph-ragknowledge-graphllmontologyprovenancepythonreasoningsemantic-search
import unittest
from unittest.mock import patch, MagicMock
from pathlib import Path
import json
import semantica.utils.helpers as helpers
import semantica.utils.validators as validators
from semantica.utils.exceptions import ValidationError
class TestHelpers(unittest.TestCase):
def test_clean_text(self):
self.assertEqual(helpers.clean_text(" Hello World "), "Hello World")
self.assertEqual(helpers.clean_text("Line 1\nLine 2"), "Line 1 Line 2")
def test_format_data_json(self):
data = {"key": "value"}
formatted = helpers.format_data(data, "json")
self.assertIn('"key": "value"', formatted)
def test_format_data_invalid(self):
with self.assertRaises(ValueError):
helpers.format_data({}, "unknown")
def test_ensure_directory(self):
with patch("pathlib.Path.mkdir") as mock_mkdir:
helpers.ensure_directory("test_dir")
mock_mkdir.assert_called_once()
def test_merge_dicts(self):
dict1 = {"a": 1, "b": {"c": 2}}
dict2 = {"b": {"d": 3}, "e": 4}
merged = helpers.merge_dicts(dict1, dict2, deep=True)
self.assertEqual(merged, {"a": 1, "b": {"c": 2, "d": 3}, "e": 4})
def test_flatten_dict(self):
"""Basic nested flattening with multiple sibling keys."""
data = {"a": {"b": 1, "c": 2}, "d": 3}
result = helpers.flatten_dict(data)
self.assertEqual(result, {"a.b": 1, "a.c": 2, "d": 3})
def test_flatten_dict_deeply_nested(self):
"""Deeply nested structure is fully flattened."""
self.assertEqual(
helpers.flatten_dict({"a": {"b": {"c": 1}}}),
{"a.b.c": 1},
)
def test_flatten_dict_custom_separator(self):
"""Custom separator is used in generated keys."""
self.assertEqual(
helpers.flatten_dict({"a": {"b": 1}}, sep="__"),
{"a__b": 1},
)
def test_flatten_dict_empty(self):
"""Empty input returns empty output."""
self.assertEqual(helpers.flatten_dict({}), {})
def test_flatten_dict_key_collision(self):
"""#1010 regression: a top-level key containing the separator must not
silently overwrite a value produced from a nested dict when both resolve
to the same flattened key. Before the fix, {'a.b': 1, 'a': {'b': 2}}
silently dropped one value; now it raises ValueError."""
with self.assertRaises(ValueError) as ctx:
helpers.flatten_dict({"a.b": 1, "a": {"b": 2}})
self.assertIn("Key collision", str(ctx.exception))
self.assertIn("a.b", str(ctx.exception))
def test_flatten_dict_no_false_positive(self):
"""Similar-looking keys that produce distinct flattened keys must not
trigger the collision guard."""
self.assertEqual(
helpers.flatten_dict({"a.b": 1, "a": {"c": 2}}),
{"a.b": 1, "a.c": 2},
)
def test_safe_import_returns_module_and_flag(self):
module, available = helpers.safe_import("json")
self.assertTrue(available)
self.assertIs(module, json)
class TestValidators(unittest.TestCase):
def test_validate_data_required_fields(self):
data = {"name": "Alice"}
is_valid, error = validators.validate_data(
data, required_fields=["name", "age"]
)
self.assertFalse(is_valid)
self.assertIn("age", error)
def test_validate_data_types(self):
data = {"name": "Alice", "age": "30"}
is_valid, error = validators.validate_data(
data, field_types={"name": str, "age": int}
)
self.assertFalse(is_valid)
self.assertIn("age", error)
def test_validate_entity(self):
entity = {"id": "e1", "text": "Alice", "type": "Person"}
is_valid, error = validators.validate_entity(entity)
self.assertTrue(is_valid)
def test_validate_entity_invalid(self):
entity = {"text": "Alice"} # Missing id and type
is_valid, error = validators.validate_entity(entity)
self.assertFalse(is_valid)
def test_validate_url(self):
self.assertTrue(validators.validate_url("https://example.com")[0])
self.assertFalse(validators.validate_url("invalid-url")[0])
def test_validate_email(self):
self.assertTrue(validators.validate_email("[email protected]")[0])
self.assertFalse(validators.validate_email("invalid-email")[0])
if __name__ == "__main__":
unittest.main()