chartflow 0.1__py3-none-any.whl

chartflow/fsm/test/test_logic.py

@@ -0,0 +1,371 @@
+"""Tests for Logic class"""
+
+from chartflow.fsm.meta import StageMachineMeta
+
+
+import pytest
+from chartflow.fsm.logic import Logic
+from chartflow.fsm.scheduler import Scheduler
+from chartflow.fsm.meta import clear_prototypes
+
+
+@pytest.fixture(autouse=True)
+def reset_state():
+    """Reset state before each test"""
+    Scheduler._instance = None
+    clear_prototypes()
+    Logic._Logic__names__ = {}
+    Logic._Logic__types__ = {}
+    StageMachineMeta.__ID_PROTOS__ = {}
+    yield
+    Scheduler._instance = None
+
+
+class MockKnowledge:
+    """Mock knowledge object"""
+    pass
+
+
+class TestLogicInit:
+    """Test Logic initialization"""
+    
+    def test_logic_auto_registers(self):
+        """Test that Logic auto-registers with Scheduler"""
+        scheduler = Scheduler()
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic = TestLogic()
+        
+        assert logic in scheduler
+    
+    def test_logic_tracks_instances(self):
+        """Test that Logic tracks instances by name"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic1 = TestLogic()
+        logic2 = TestLogic()
+        
+        instances = Logic._Logic__names__.get("TestLogic", {})
+        assert logic1.uid in instances
+        assert logic2.uid in instances
+
+
+class TestLogicLifecycle:
+    """Test Logic lifecycle methods"""
+    
+    def test_check_method(self):
+        """Test _check method"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic = TestLogic()
+        
+        assert logic._check(False) is True
+    
+    def test_enter_method(self):
+        """Test _enter method calls onStart"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def __init__(self):
+                self.started = False
+                super().__init__()
+            
+            def my_state(self, inst):
+                return None
+            
+            def onStart(self, it):
+                self.started = True
+        
+        logic = TestLogic()
+        logic._enter()
+        
+        assert logic.started
+        assert logic._isEntered
+    
+    def test_step_method(self):
+        """Test _step method calls handleStage and onStep"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def __init__(self):
+                self.stepped = False
+                super().__init__()
+            
+            def my_state(self, inst):
+                return None
+            
+            def onStep(self, it):
+                self.stepped = True
+        
+        logic = TestLogic()
+        logic._current = "my_state"
+        logic._step()
+        
+        assert logic.stepped
+    
+    def test_exit_method(self):
+        """Test _exit method calls onStop"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def __init__(self):
+                self.stopped = False
+                super().__init__()
+            
+            def my_state(self, inst):
+                return None
+            
+            def onStop(self, it):
+                self.stopped = True
+        
+        logic = TestLogic()
+        logic._exit()
+        
+        assert logic.stopped
+
+
+class TestLogicProperties:
+    """Test Logic properties"""
+    
+    def test_alive_property(self):
+        """Test alive property"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic = TestLogic()
+        
+        assert logic.alive is True
+        
+        logic.alive = False
+        
+        assert logic.alive is False
+    
+    def test_enabled_property(self):
+        """Test enabled property"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic = TestLogic()
+        
+        assert logic.enabled is True
+        
+        logic.enabled = False
+        
+        assert logic.enabled is False
+    
+    def test_uid_property(self):
+        """Test uid property"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic1 = TestLogic()
+        logic2 = TestLogic()
+        
+        assert logic1.uid == 0
+        assert logic2.uid == 1
+    
+    def test_priority_property(self):
+        """Test priority property"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            PRIORITY = 5
+            
+            def my_state(self, inst):
+                return None
+        
+        logic = TestLogic()
+        
+        assert logic.priority == 5
+
+
+class TestLogicRef:
+    """Test Logic reference methods"""
+    
+    def test_ref_by_name(self):
+        """Test ref() by base name returns list"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic1 = TestLogic()
+        logic2 = TestLogic()
+        
+        refs = logic1.ref("TestLogic")
+
+        assert isinstance(refs, list)
+        assert logic1 in refs
+        assert logic2 in refs
+
+    def test_ref_by_full_name(self):
+        """Test ref() by full name returns single instance"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic1 = TestLogic()
+        logic2 = TestLogic()
+        
+        ref1 = logic1.ref("TestLogic0")
+        ref2 = logic2.ref("TestLogic1")
+        
+        assert ref1 is logic1
+        assert ref2 is logic2
+    
+    def test_ref_last(self):
+        """Test refLast() returns previous instance"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic1 = TestLogic()
+        logic2 = TestLogic()
+        
+        assert logic2.refLast() is logic1
+        assert logic1.refLast() is None
+    
+    def test_ref_next(self):
+        """Test refNext() returns next instance"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic1 = TestLogic()
+        logic2 = TestLogic()
+        
+        assert logic1.refNext() is logic2
+        assert logic2.refNext() is None
+    
+    def test_ref_adjacent(self):
+        """Test refAdjacent() returns prev and next"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic1 = TestLogic()
+        logic2 = TestLogic()
+        logic3 = TestLogic()
+        
+        prev, next = logic2.refAdjacent()
+        
+        assert prev is logic1
+        assert next is logic3
+    
+    def test_ref_head(self):
+        """Test refHead() returns first instance"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic1 = TestLogic()
+        logic2 = TestLogic()
+        
+        assert logic1.refHead() is logic1
+    
+    def test_ref_end(self):
+        """Test refEnd() returns last instance"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic1 = TestLogic()
+        logic2 = TestLogic()
+        
+        assert logic1.refEnd() is logic2
+
+
+class TestLogicKill:
+    """Test Logic kill functionality"""
+    
+    def test_kill_sets_alive_false(self):
+        """Test kill() sets alive to False"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic = TestLogic()
+        
+        assert logic.alive is True
+        
+        logic.kill()
+        
+        assert logic.alive is False
+
+
+class TestLogicControl:
+    """Test Logic control methods"""
+    
+    def test_enable_disable(self):
+        """Test enable() and disable() methods"""
+        
+        class TestLogic(Logic):
+            NAME = "TestLogic"
+            
+            def my_state(self, inst):
+                return None
+        
+        logic = TestLogic()
+        
+        assert logic.enabled is True
+        
+        logic.disable()
+        
+        assert logic.enabled is False
+        
+        logic.enable()
+        
+        assert logic.enabled is True

chartflow/fsm/test/test_meta.py

@@ -0,0 +1,192 @@
+"""Tests for StageMachineMeta metaclass"""
+
+import pytest
+from chartflow.fsm.meta import StageMachineMeta, get_prototype, list_prototypes, clear_prototypes
+
+
+class TestStateDiscovery:
+    """Test automatic state discovery"""
+    
+    def test_basic_state_discovery(self):
+        """Test that methods become states"""
+        clear_prototypes()
+        
+        class TestStage(metaclass=StageMachineMeta):
+            NAME = "TestStage"
+            
+            def state_a(self, inst):
+                return "state_b"
+            
+            def state_b(self, inst):
+                return "state_a"
+        
+        assert "state_a" in TestStage.__states__
+        assert "state_b" in TestStage.__states__
+    
+    def test_private_methods_not_states(self):
+        """Test that _private methods are not states"""
+        clear_prototypes()
+        
+        class TestStage(metaclass=StageMachineMeta):
+            NAME = "TestStage"
+            
+            def public_state(self, inst):
+                return None
+            
+            def _private_method(self):
+                pass
+        
+        assert "public_state" in TestStage.__states__
+        assert "_private_method" not in TestStage.__states__
+    
+    def test_uppercase_methods_not_states(self):
+        """Test that UPPERCASE methods are not states"""
+        clear_prototypes()
+        
+        class TestStage(metaclass=StageMachineMeta):
+            NAME = "TestStage"
+            
+            def normal_state(self, inst):
+                return None
+            
+            def CONSTANT(self):
+                pass
+        
+        assert "normal_state" in TestStage.__states__
+        assert "CONSTANT" not in TestStage.__states__
+    
+    def test_ignored_methods_not_states(self):
+        """Test that ignored methods are not states"""
+        clear_prototypes()
+        
+        class TestStage(metaclass=StageMachineMeta):
+            NAME = "TestStage"
+            
+            def normal_state(self, inst):
+                return None
+            
+            def onLoading(self, it, k, *children):
+                pass
+        
+        assert "normal_state" in TestStage.__states__
+        assert "onLoading" not in TestStage.__states__
+
+
+class TestClassRegistration:
+    """Test automatic class registration"""
+    
+    def test_class_registered(self):
+        """Test that classes with NAME are registered"""
+        clear_prototypes()
+        
+        class TestStage(metaclass=StageMachineMeta):
+            NAME = "TestStage"
+            
+            def state_a(self, inst):
+                return None
+        
+        proto = get_prototype("TestStage")
+        assert proto is TestStage
+    
+    def test_base_classes_not_registered(self):
+        """Test that base classes are not registered"""
+        clear_prototypes()
+        
+        class Stage(metaclass=StageMachineMeta):
+            NAME = "Stage"
+        
+        class Logic(Stage):
+            NAME = "Logic"
+        
+        assert get_prototype("Stage") is None
+        assert get_prototype("Logic") is None
+    
+    def test_name_validation(self):
+        """Test that NAME ending with digit is rejected"""
+        clear_prototypes()
+        
+        with pytest.raises(ValueError):
+            class BadStage(metaclass=StageMachineMeta):
+                NAME = "BadStage1"
+
+
+class TestInheritance:
+    """Test state and decorator inheritance"""
+    
+    def test_states_inherited(self):
+        """Test that states are inherited from parent"""
+        clear_prototypes()
+        
+        class BaseStage(metaclass=StageMachineMeta):
+            NAME = "BaseStage"
+            
+            def base_state(self, inst):
+                return None
+        
+        class DerivedStage(BaseStage):
+            NAME = "DerivedStage"
+            
+            def derived_state(self, inst):
+                return None
+        
+        assert "base_state" in DerivedStage.__states__
+        assert "derived_state" in DerivedStage.__states__
+    
+    def test_recursive_inherited(self):
+        """Test that recursive markers are inherited"""
+        clear_prototypes()
+        
+        class BaseStage(metaclass=StageMachineMeta):
+            NAME = "BaseStage"
+            
+            def base_state(self, inst):
+                return None
+        
+        BaseStage.__recursive__ = {"base_state"}
+        
+        class DerivedStage(BaseStage):
+            NAME = "DerivedStage"
+            
+            def derived_state(self, inst):
+                return None
+        
+        assert "base_state" in DerivedStage.__recursive__
+
+
+class TestPrototypeFunctions:
+    """Test prototype utility functions"""
+    
+    def test_get_prototype(self):
+        """Test get_prototype function"""
+        clear_prototypes()
+        
+        class TestStage(metaclass=StageMachineMeta):
+            NAME = "TestStage"
+        
+        assert get_prototype("TestStage") is TestStage
+        assert get_prototype("NonExistent") is None
+    
+    def test_list_prototypes(self):
+        """Test list_prototypes function"""
+        clear_prototypes()
+        
+        class TestStageAlpha(metaclass=StageMachineMeta):
+            NAME = "TestStageAlpha"
+        
+        class TestStageBeta(metaclass=StageMachineMeta):
+            NAME = "TestStageBeta"
+        
+        protos = list_prototypes()
+        assert "TestStageAlpha" in protos
+        assert "TestStageBeta" in protos
+    
+    def test_clear_prototypes(self):
+        """Test clear_prototypes function"""
+        clear_prototypes()
+        
+        class TestStage(metaclass=StageMachineMeta):
+            NAME = "TestStage"
+        
+        assert get_prototype("TestStage") is TestStage
+        clear_prototypes()
+        assert get_prototype("TestStage") is None