Index: tests/test_phase.py =================================================================== --- tests/test_phase.py (revision daa22762d0f497f098e4974c25488ee08af22cd4) +++ tests/test_phase.py (revision d7a66adcde1b540a909fdf9593a32fcc0db09e1b) @@ -32,6 +32,6 @@ phase = Phase("Warm-up", 300) phase.abort() - assert phase.state == "finished" - assert phase.finished() is True + assert phase.state == "aborted" + assert phase.aborted() is True def test_phase_tick(self): @@ -47,5 +47,5 @@ phase.tick(300) assert phase.ticks_left == 0 - assert phase.finished() is True + assert phase.completed() is True def test_phase_tick_beyond_completion(self): Index: tests/test_recurring_phase_sequence.py =================================================================== --- tests/test_recurring_phase_sequence.py (revision daa22762d0f497f098e4974c25488ee08af22cd4) +++ tests/test_recurring_phase_sequence.py (revision d7a66adcde1b540a909fdf9593a32fcc0db09e1b) @@ -10,7 +10,5 @@ @pytest.fixture def recurring_phase_sequence(self): - phase_list = [Phase("Huddle", 10), Phase("Tasking", 5), - Phase("Work", 45), Phase("Break", 15)] - return RecurringPhaseSequence(phase_list, 3) + return RecurringPhaseSequence.default() def test_from_json(self): @@ -19,6 +17,6 @@ assert isinstance(sequence, RecurringPhaseSequence) assert sequence.initial_repetitions == 3 - assert len(sequence.phase_list) == 4 - assert sequence.phase_list[0].title == "Huddle" + assert len(sequence.phase_list) == 3 + assert sequence.phase_list[0].title == "Tasking" def test_to_json(self, recurring_phase_sequence): @@ -28,9 +26,9 @@ assert data['initial_repetitions'] == 3 assert data['passes_left'] == 3 - assert len(data['phase_list']) == 4 + assert len(data['phase_list']) == 3 def test_initial_state(self, recurring_phase_sequence): assert recurring_phase_sequence.state == "initial" - assert recurring_phase_sequence.current_phase.title == "Huddle" + assert recurring_phase_sequence.current_phase.title == "Tasking" assert recurring_phase_sequence.passes_left == 3 @@ -41,12 +39,12 @@ def test_phases_left_in_pass(self, recurring_phase_sequence): - assert recurring_phase_sequence.phases_left_in_pass() == 3 + assert recurring_phase_sequence.phases_left_in_pass() == 2 recurring_phase_sequence.tick(10) - assert recurring_phase_sequence.phases_left_in_pass() == 2 + assert recurring_phase_sequence.phases_left_in_pass() == 1 def test_upcoming_phases_in_pass(self, recurring_phase_sequence): upcoming = recurring_phase_sequence.upcoming_phases_in_pass() - assert len(upcoming) == 3 - assert upcoming[0].title == "Tasking" + assert len(upcoming) == 2 + assert upcoming[0].title == "Work" def test_ticks_left(self, recurring_phase_sequence): @@ -58,22 +56,18 @@ assert recurring_phase_sequence.ticks_left == (total_ticks - 10) - def test_finished(self, recurring_phase_sequence): - assert not recurring_phase_sequence.finished() + def test_completed(self, recurring_phase_sequence): + assert not recurring_phase_sequence.completed() for _ in range(3): for phase in recurring_phase_sequence.phase_list: recurring_phase_sequence.tick(phase.initial_ticks) - assert recurring_phase_sequence.finished() + assert recurring_phase_sequence.completed() def test_abort(self, recurring_phase_sequence): recurring_phase_sequence.abort() - assert recurring_phase_sequence.state == "finished" - assert recurring_phase_sequence.current_phase.finished() + assert recurring_phase_sequence.state == "aborted" + assert recurring_phase_sequence.current_phase.aborted() def test_tick_progression(self, recurring_phase_sequence): - recurring_phase_sequence.tick(10) - assert recurring_phase_sequence.current_phase.title == "Tasking" - assert recurring_phase_sequence.passes_left == 3 - - recurring_phase_sequence.tick(5) + recurring_phase_sequence.tick(6) assert recurring_phase_sequence.current_phase.title == "Work" assert recurring_phase_sequence.passes_left == 3 @@ -84,10 +78,10 @@ recurring_phase_sequence.tick(15) - assert recurring_phase_sequence.current_phase.title == "Huddle" + assert recurring_phase_sequence.current_phase.title == "Tasking" assert recurring_phase_sequence.passes_left == 2 def test_unrolled(self, recurring_phase_sequence): unrolled_phases = recurring_phase_sequence.unrolled() - assert len(unrolled_phases) == 12 - assert unrolled_phases[0].title == "Huddle" + assert len(unrolled_phases) == 9 + assert unrolled_phases[0].title == "Tasking" assert unrolled_phases[-1].title == "Break" Index: tests/test_schedule.py =================================================================== --- tests/test_schedule.py (revision daa22762d0f497f098e4974c25488ee08af22cd4) +++ tests/test_schedule.py (revision d7a66adcde1b540a909fdf9593a32fcc0db09e1b) @@ -1,110 +1,112 @@ import pytest +import json from flowtimer.Schedule import Schedule from flowtimer.Phase import Phase +from flowtimer.RecurringPhaseSequence import RecurringPhaseSequence + class TestSchedule: - - def test_schedule_initialization(self): - phase1 = Phase("Warm-up", 300) - phase2 = Phase("Workout", 600) - schedule = Schedule([phase1, phase2]) - - assert schedule.phase_list == [phase1, phase2] - assert schedule.current_phase == phase1 + + @pytest.fixture + def setup_schedule(self): + # Set up some real Phase and RecurringPhaseSequence objects for testing + phase1 = Phase("Phase 1", 300) + phase2 = Phase("Phase 2", 600) + sequence = RecurringPhaseSequence("Sequence 1", [phase1, phase2], 2) + blocks = [phase1, sequence] + schedule = Schedule("Test Schedule", blocks) + return schedule, phase1, phase2, sequence + + def test_initialization(self, setup_schedule): + schedule, phase1, _, _ = setup_schedule + assert schedule.title == "Test Schedule" + assert schedule.blocks == [phase1, schedule.blocks[1]] + assert schedule.current_block == phase1 assert schedule.state == "initial" - def test_schedule_start(self): - phase1 = Phase("Warm-up", 300) - schedule = Schedule([phase1]) + def test_default_json_string(self): + default_json = Schedule.default_json_string() + assert isinstance(default_json, str) + + def test_from_json(self): + json_string = Schedule.default_json_string() + schedule = Schedule.from_json(json_string) + assert schedule.title == "Default" + assert len(schedule.blocks) == 2 + assert isinstance(schedule.blocks[0], Phase) + assert isinstance(schedule.blocks[1], RecurringPhaseSequence) + + def test_to_json(self, setup_schedule): + schedule, _, _, _ = setup_schedule + json_string = schedule.to_json() + assert isinstance(json_string, str) + data = json.loads(json_string) + assert data['title'] == "Test Schedule" + assert len(data['blocks']) == 2 + + def test_start(self, setup_schedule): + schedule, phase1, _, _ = setup_schedule schedule.start() - assert schedule.state == "running" - assert schedule.current_phase.running() is True - - def test_schedule_pause(self): - phase1 = Phase("Warm-up", 300) - schedule = Schedule([phase1]) + # assert phase1.ticks_left < phase1.initial_ticks # Assuming the phase reduces ticks when started + + def test_running(self, setup_schedule): + schedule, _, _, _ = setup_schedule schedule.start() + assert schedule.running() is True schedule.pause() - - assert schedule.state == "paused" - assert schedule.is_paused() is True + assert schedule.running() is False - def test_schedule_abort(self): - phase1 = Phase("Warm-up", 300) - schedule = Schedule([phase1]) - schedule.start() + def test_paused(self, setup_schedule): + schedule, _, _, _ = setup_schedule + schedule.pause() + assert schedule.paused() is True + + def test_abort(self, setup_schedule): + schedule, _, _, _ = setup_schedule schedule.abort() - - assert schedule.state == "finished" - assert schedule.current_phase.finished() is True + assert schedule.state == "aborted" - def test_schedule_finished(self): - phase1 = Phase("Warm-up", 300) - phase2 = Phase("Workout", 600) - schedule = Schedule([phase1, phase2]) - - assert schedule.finished() is False - - phase1.start() - phase1.tick(300) - assert phase1.finished() is True - assert schedule.finished() is False - + def test_completed(self, setup_schedule): + schedule, phase1, _, sequence = setup_schedule + schedule.tick(phase1.initial_ticks) # Complete phase1 + schedule.tick(sequence.initial_ticks) # Complete sequence + schedule.tick(phase1.initial_ticks) # Complete phase1 + schedule.tick(sequence.initial_ticks) # Complete sequence + print(schedule.current_block) + assert schedule.completed() is True + assert schedule.state == "completed" + + def test_advance_to_next_block(self, setup_schedule): + schedule, _, _, sequence = setup_schedule + schedule.advance_to_next_block() + assert schedule.current_block == schedule.blocks[1] + + def test_skip(self, setup_schedule): + schedule, _, _, sequence = setup_schedule schedule.skip() - schedule.current_phase.tick(600) - assert schedule.finished() is True + assert schedule.current_block == schedule.blocks[1] # Should skip to Phase 2 within the sequence - def test_schedule_skip(self): - phase1 = Phase("Warm-up", 300) - phase2 = Phase("Workout", 600) - schedule = Schedule([phase1, phase2]) - - schedule.start() - schedule.skip() - - assert schedule.current_phase == phase2 + def test_total_ticks_left(self, setup_schedule): + schedule, phase1, phase2, sequence = setup_schedule + expected_total_ticks = phase1.ticks_left + sequence.ticks_left + assert schedule.total_ticks_left() == expected_total_ticks - def test_schedule_skip_at_final_phase(self): - phase1 = Phase("Warm-up", 300) - schedule = Schedule([phase1]) - - schedule.start() - schedule.skip() - - assert schedule.state == "finished" + def test_upcoming_blocks(self, setup_schedule): + schedule, _, _, sequence = setup_schedule + assert schedule.upcoming_blocks() == [sequence] - def test_schedule_tick(self): - phase1 = Phase("Warm-up", 300) - phase2 = Phase("Workout", 600) - schedule = Schedule([phase1, phase2]) - - schedule.start() - schedule.tick(300) - - assert phase1.finished() is True - assert schedule.current_phase == phase2 - assert schedule.state == "running" + def test_current_block_is_final(self, setup_schedule): + schedule, _, _, sequence = setup_schedule + assert schedule.current_block_is_final() is False + schedule.advance_to_next_block() + assert schedule.current_block_is_final() is True - def test_schedule_tick_to_completion(self): - phase1 = Phase("Warm-up", 300) - phase2 = Phase("Workout", 600) - schedule = Schedule([phase1, phase2]) - - schedule.start() - schedule.tick(300) # Should finish phase1 and move to phase2 - schedule.tick(600) # Should finish phase2 and complete the schedule - - assert phase2.finished() is True - assert schedule.finished() is True + def test_tick(self, setup_schedule): + schedule, phase1, _, _ = setup_schedule + initial_ticks = phase1.ticks_left + schedule.tick(100) + assert phase1.ticks_left == initial_ticks - 100 - def test_schedule_current_phase_is_final(self): - phase1 = Phase("Warm-up", 300) - phase2 = Phase("Workout", 600) - schedule = Schedule([phase1, phase2]) - - assert schedule.current_phase_is_final() is False - - schedule.skip() - assert schedule.current_phase_is_final() is True - + schedule.tick(phase1.ticks_left) # Finish phase1 + assert schedule.current_block == schedule.blocks[1] # Should advance to the next block