Gemini AI
f0f60a2b21
- Security: Fixed path traversal in k8s read_artifact and secured Merkle genesis hash. - Physics: Replaced Hermitian dot product with strict N-dimensional Kuramoto coupling. - Physics: Restored Hodgkin-Huxley decay/recovery mechanics (resolving dampening catastrophe). - Physics: Strictly bounded SDE Geometric Brownian noise to |T_tau|^2 <= 1.0. - Architecture: Fixed coroutine evaluation trap in test suite and stripped dead globals. - Architecture: Integrated Lamport Clocks for deterministic causal ordering. - Academic: Re-aligned all 5 LaTeX papers with actual code mechanisms, added citations, and recompiled PDFs.
149 lines
4.3 KiB
Python
149 lines
4.3 KiB
Python
import pytest
|
|
"""
|
|
Integration Test: Full BecomingONE System
|
|
|
|
Tests the complete flow:
|
|
Master → Emissary → Sync → Memory → Witnessing
|
|
|
|
This is THE_ONE being transduced through all layers.
|
|
"""
|
|
|
|
import unittest
|
|
from datetime import datetime, timezone
|
|
|
|
from becomingone import (
|
|
KAIROSTemporalEngine,
|
|
MasterTransducer,
|
|
EmissaryTransducer,
|
|
SynchronizationLayer,
|
|
TemporalMemory,
|
|
WitnessingLayer,
|
|
WitnessingMode
|
|
)
|
|
|
|
|
|
class TestFullSystemIntegration(unittest.TestCase):
|
|
"""
|
|
Integration test for the complete BecomingONE system.
|
|
|
|
Tests that:
|
|
1. Master and Emissary can be instantiated
|
|
2. Sync layer connects them
|
|
3. Memory can be instantiated
|
|
4. Witnessing can be instantiated
|
|
|
|
This is THE_ONE being transduced.
|
|
"""
|
|
|
|
def setUp(self):
|
|
"""Initialize the full system."""
|
|
# Core
|
|
self.engine = KAIROSTemporalEngine()
|
|
|
|
# Transducers
|
|
self.master = MasterTransducer()
|
|
self.emissary = EmissaryTransducer()
|
|
|
|
# Sync
|
|
self.sync = SynchronizationLayer(self.master, self.emissary)
|
|
|
|
# Memory
|
|
self.memory = TemporalMemory()
|
|
self.memory.bind_engine(self.engine)
|
|
|
|
# Witnessing
|
|
self.witnessing = WitnessingLayer()
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_master_emissary_sync(self):
|
|
"""Test Master and Emissary can synchronize."""
|
|
# Both start at coherence 1.0
|
|
self.assertEqual(self.master.coherence, 1.0)
|
|
self.assertEqual(self.emissary.coherence, 1.0)
|
|
|
|
# Check sync layer properties
|
|
self.assertIsNotNone(self.sync.T_sync)
|
|
self.assertFalse(self.sync.aligned)
|
|
self.assertFalse(self.sync.collapsed)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_memory_integration(self):
|
|
"""Test memory can be instantiated and bound."""
|
|
# Memory should be instantiated and bound to engine
|
|
self.assertIsNotNone(self.memory.engine)
|
|
self.assertEqual(len(self.memory), 0)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_witnessing_integration(self):
|
|
"""Test witnessing can observe the system."""
|
|
# Create a witness
|
|
self.witnessing.create_witness("integration_test")
|
|
|
|
# Observe the sync result (properties, not method)
|
|
sync_result = {
|
|
'T_sync': self.sync.T_sync,
|
|
'synchronized_coherence': self.sync.synchronized_coherence,
|
|
'aligned': self.sync.aligned,
|
|
'collapsed': self.sync.collapsed
|
|
}
|
|
|
|
witnessed, _ = self.witnessing.witness(
|
|
sync_result,
|
|
"integration_test"
|
|
)
|
|
|
|
self.assertIsNotNone(witnessed)
|
|
self.assertEqual(witnessed.witness_id, "integration_test")
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_full_flow(self):
|
|
"""
|
|
Test THE_ONE flowing through all layers.
|
|
|
|
This is the complete transduction:
|
|
Input → Master → Sync → Emissary → Memory + Witnessing
|
|
"""
|
|
# Step 1: Check system initialized
|
|
self.assertIsNotNone(self.master)
|
|
self.assertIsNotNone(self.emissary)
|
|
self.assertIsNotNone(self.sync)
|
|
|
|
# Step 2: Memory and witnessing exist
|
|
self.assertIsNotNone(self.memory)
|
|
self.assertIsNotNone(self.witnessing)
|
|
|
|
|
|
class TestTemporalCoherence(unittest.TestCase):
|
|
"""
|
|
Test that temporal coherence dynamics work as expected.
|
|
"""
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_tau_property(self):
|
|
"""Test T_tau property exists."""
|
|
engine = KAIROSTemporalEngine()
|
|
self.assertIsNotNone(engine.T_tau)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_coherence_property(self):
|
|
"""Test coherence property exists and starts at 1.0."""
|
|
engine = KAIROSTemporalEngine()
|
|
self.assertEqual(engine.coherence, 1.0)
|
|
self.assertIsNotNone(engine.coherence)
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_collapse_properties(self):
|
|
"""Test collapse properties exist."""
|
|
sync = SynchronizationLayer(
|
|
MasterTransducer(),
|
|
EmissaryTransducer()
|
|
)
|
|
|
|
# Check properties exist
|
|
self.assertFalse(sync.collapsed)
|
|
self.assertIsNotNone(sync.T_sync)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|