Changeset df0449c in flowtimer

Timestamp:

08/31/24 14:57:29 (9 months ago)

Author:

Enrico Schwass <ennoausberlin@…>

Branches:

guix

Children:

f2a2a82

Parents:

8f41b95

Message:

fix one remaining unit test

Files:

• flowtimer/Phase.py (modified) (3 diffs)
• flowtimer/RecurringPhaseSequence.py (modified) (6 diffs)
• flowtimer/Schedule.py (modified) (2 diffs)
• flowtimer/flowtimer_logging.conf (added)
• tests/test_phase.py (modified) (3 diffs)
• tests/test_recurring_phase_sequence.py (modified) (1 diff)

flowtimer/Phase.py

@@ -7 +7 @@
     This class is a representation of a single phase inside a timer
     """
+
+    @classmethod
+    def default(cls):
+        return cls('Default', 30)
 
     def __init__(self, title, ticks):
@@ -71 +75 @@
     def is_running(self):
         return self._state == "running"
-        # return self.time_left > 0
 
     def is_terminated(self):
@@ -83 +86 @@
 
     def tick(self, ticks):
+        self.start()
         result = self._ticks_left - ticks
 
-        if result <= 0:
+        if result < 1:
             self._ticks_left = 0
             self._state = "completed"

flowtimer/RecurringPhaseSequence.py

@@ -70 +70 @@
     def ticks_left(self):
         return (
-            (self.passes_left-1) * sum([each.initial_ticks for each in self.phases]) +
+            (self.passes_left) * sum([each.initial_ticks for each in self.phases]) +
             self.current_phase.ticks_left +
             sum([each.ticks_left for each in self.upcoming_phases_in_pass()]))
@@ -80 +80 @@
 
     def is_final_round(self):
-        print("Final round", self.passes_left)
         return self.passes_left == 0
 
@@ -108 +107 @@
         else:
             if self.is_final_round():
-                print("Abort on final round")
                 self.abort()
                 return
             else:
                 self.passes_left -= 1
-                print("Skip", self.passes_left)
                 self.current_phase.reset()
                 self.current_phase = self.phases[0]
@@ -123 +120 @@
             self.current_phase.reset()
             self.current_phase = self.phases[current_index + 1]
+            # self.current_phase.start()
         else:
             # Completed a full sequence; check if more repetitions are needed
@@ -128 +126 @@
             if self.passes_left < 1:
                 self._state = "completed"
-                print("Passes left", self.passes_left)
             else:
                 self.current_phase.reset()
                 self.current_phase = self.phases[0]  # Reset to the first phase
+                # self.current_phase.start()
 
     def tick(self, ticks):
@@ -139 +137 @@
                 self.advance_to_next_phase()
                 result = self.tick(abs(result))
-                return
+                return result
+            return result
+        else:
+            return 0
 
     def unrolled(self):

flowtimer/Schedule.py

@@ -144 +144 @@
     def skip(self):
         if self.current_block.is_sequence():
-            print("Skip the next phase in sequence")
             self.current_block.skip()
             if self.current_block.is_terminated():
@@ -153 +152 @@
             return
         if self.current_block_is_final():
-            print("Time over")
             self.abort()
             return

tests/test_phase.py

@@ -2 +2 @@
 from flowtimer.Phase import Phase
 
+
 class TestPhase:
 
-    def test_phase_initialization(self):
-        phase = Phase("Warm-up", 300)
-        assert phase.title == "Warm-up"
-        assert phase.initial_ticks == 300
+    @pytest.fixture
+    def phase(self):
+        return Phase.default()
+
+    def test_phase_initialization(self, phase):
+        assert phase.title == "Default"
+        assert phase.initial_ticks == 30
         assert phase.state == "initial"
-        assert phase.ticks_left == 300
+        assert phase.ticks_left == 30
 
 #    def test_phase_str_representation(self):
@@ -16 +20 @@
 #        assert str(phase) == expected_str
 
-    def test_phase_start(self):
-        phase = Phase("Warm-up", 300)
+    def test_phase_start(self, phase):
         phase.start()
         assert phase.state == "running"
         assert phase.is_running() is True
 
-    def test_phase_pause(self):
-        phase = Phase("Warm-up", 300)
+    def test_phase_pause(self, phase):
         phase.start()
         phase.pause()
@@ -29 +31 @@
         assert phase.is_paused() is True
 
-    def test_phase_abort(self):
-        phase = Phase("Warm-up", 300)
+    def test_phase_abort(self, phase):
         phase.abort()
         assert phase.state == "aborted"
         assert phase.is_aborted() is True
 
-    def test_phase_tick(self):
-        phase = Phase("Warm-up", 300)
+    def test_phase_tick(self, phase):
         phase.start()
-        phase.tick(60)
-        assert phase.ticks_left == 240
+        phase.tick(10)
+        assert phase.ticks_left == 20
         assert phase.state == "running"
+        assert phase.is_running()
 
-    def test_phase_tick_to_completion(self):
-        phase = Phase("Warm-up", 300)
+    def test_phase_tick_to_completion(self, phase):
         phase.start()
-        phase.tick(300)
+        phase.tick(30)
         assert phase.ticks_left == 0
         assert phase.is_completed() is True
+        assert phase.state == 'completed'
 
-    def test_phase_tick_beyond_completion(self):
-        phase = Phase("Warm-up", 300)
+    def test_phase_tick_beyond_completion(self, phase):
         phase.start()
         phase.tick(350)
         assert phase.ticks_left == 0
+        assert phase.is_completed() is True
+        assert phase.state == 'completed'

tests/test_recurring_phase_sequence.py

@@ -50 +50 @@
         total_ticks = (sum([phase.initial_ticks for phase in recurring_phase_sequence.phases]) *
                        recurring_phase_sequence.initial_repetitions)
-
         assert recurring_phase_sequence.ticks_left == total_ticks
         recurring_phase_sequence.tick(10)