from datetime import date, datetime, time, timedelta from zoneinfo import ZoneInfo from django.contrib.auth import get_user_model from django.core.exceptions import ValidationError from django.core.management import call_command from django.test import TestCase from django.utils import timezone from django.urls import reverse from .models import FastingPause, FastingPeriod, FastingSettings, SickDaySettings, Task from .forms import DAILY_FASTING_DURATION_CHOICES, FastingSettingsForm from .services.deferrals import ( apply_missed_task_deferrals, defer_task_manually, sync_sick_day_deferrals, ) from .services.fasting import ( configure_fasting, current_fasting_phase, set_fasting_tracking_enabled, synchronize_fasting_periods, ) from .services.scheduling import ( daily_recommendations, duration_budget_for_energy, is_task_eligible, normalize_energy_level, recommend_tasks, ) class TaskModelTests(TestCase): def make_task(self, title='Plan project', **kwargs): defaults = {'scheduled_for': date(2026, 10, 1)} defaults.update(kwargs) return Task.objects.create(title=title, **defaults) def test_creating_a_normal_task(self): task = self.make_task() self.assertEqual(task.title, 'Plan project') self.assertIsNone(task.parent_task) self.assertTrue(task.is_active) def test_creating_a_subtask_and_reverse_relationship(self): parent = self.make_task('Parent') subtask = self.make_task('Child', parent_task=parent) self.assertEqual(subtask.parent_task, parent) self.assertQuerySetEqual(parent.subtasks.all(), [subtask]) def test_task_cannot_be_its_own_parent(self): task = self.make_task() task.parent_task = task with self.assertRaises(ValidationError) as error: task.full_clean() self.assertIn('parent_task', error.exception.message_dict) def test_task_cannot_have_a_descendant_as_parent(self): parent = self.make_task('Parent') child = self.make_task('Child', parent_task=parent) parent.parent_task = child with self.assertRaises(ValidationError) as error: parent.full_clean() self.assertIn('parent_task', error.exception.message_dict) def test_deleting_parent_promotes_children_to_top_level(self): parent = self.make_task('Parent') child = self.make_task('Child', parent_task=parent) parent.delete() child.refresh_from_db() self.assertIsNone(child.parent_task) def test_recurrence_fields_persist(self): task = self.make_task( is_recurring=True, recurrence_interval=2, recurrence_unit=Task.RecurrenceUnit.WEEK, ) task.refresh_from_db() self.assertTrue(task.is_recurring) self.assertEqual(task.recurrence_interval, 2) self.assertEqual(task.recurrence_unit, Task.RecurrenceUnit.WEEK) class TaskCRUDViewTests(TestCase): def setUp(self): self.user = get_user_model().objects.create_user(username='task-owner', password='password') self.client.force_login(self.user) def task_data(self, **overrides): data = { 'title': 'Write project notes', 'description': 'Summarise the first implementation step.', 'estimated_duration_minutes': '30', 'priority': Task.Priority.HIGH, 'category': 'Work', 'scheduled_for': '2026-10-05', 'is_recurring': 'on', 'recurrence_interval': '1', 'recurrence_unit': Task.RecurrenceUnit.WEEK, 'is_active': 'on', 'weather_profile': 'none', 'parent_task': '', 'defer_days': '', 'deferred_until': '', 'deferral_source': '', } data.update(overrides) return data def create_task(self, title='Existing task'): return Task.objects.create(owner=self.user, title=title, scheduled_for=date(2026, 10, 5)) def test_list_and_detail_views(self): task = self.create_task() response = self.client.get(reverse('planner:task-list')) self.assertEqual(response.status_code, 200) self.assertContains(response, task.title) response = self.client.get(reverse('planner:task-detail', args=[task.pk])) self.assertEqual(response.status_code, 200) self.assertContains(response, task.title) def test_create_view_creates_task(self): response = self.client.post(reverse('planner:task-create'), self.task_data()) self.assertRedirects(response, reverse('planner:task-detail', args=[Task.objects.get().pk])) task = Task.objects.get() self.assertEqual(task.title, 'Write project notes') self.assertTrue(task.is_recurring) def test_update_view_updates_task(self): task = self.create_task() response = self.client.post( reverse('planner:task-update', args=[task.pk]), self.task_data(title='Updated task', is_recurring='', recurrence_unit=''), ) self.assertRedirects(response, reverse('planner:task-detail', args=[task.pk])) task.refresh_from_db() self.assertEqual(task.title, 'Updated task') self.assertFalse(task.is_recurring) def test_delete_view_deletes_task(self): task = self.create_task() response = self.client.get(reverse('planner:task-delete', args=[task.pk])) self.assertEqual(response.status_code, 200) response = self.client.post(reverse('planner:task-delete', args=[task.pk])) self.assertRedirects(response, reverse('planner:task-list')) self.assertFalse(Task.objects.filter(pk=task.pk).exists()) def test_htmx_create_form_loads_inside_task_list(self): response = self.client.get( reverse('planner:task-create'), HTTP_HX_REQUEST='true', ) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'planner/partials/task_create_panel.html') self.assertContains(response, 'id="new-task-heading"') self.assertContains(response, 'hx-target="#task-list"') def test_htmx_create_returns_refreshed_task_list(self): response = self.client.post( reverse('planner:task-create'), self.task_data(), HTTP_HX_REQUEST='true', ) self.assertEqual(response.status_code, 200) self.assertTemplateUsed(response, 'planner/partials/task_list_content.html') self.assertContains(response, 'Write project notes') self.assertEqual(Task.objects.count(), 1) def test_htmx_filter_returns_only_matching_task_fragment(self): active = self.create_task('Active task') inactive = self.create_task('Inactive task') inactive.is_active = False inactive.save() response = self.client.get( reverse('planner:task-list'), {'status': 'active'}, HTTP_HX_REQUEST='true', ) self.assertEqual(response.status_code, 200) self.assertContains(response, active.title) self.assertNotContains(response, inactive.title) self.assertTemplateUsed(response, 'planner/partials/task_list_content.html') def test_htmx_toggle_active_replaces_task_card(self): task = self.create_task() response = self.client.post( reverse('planner:task-toggle-active', args=[task.pk]), HTTP_HX_REQUEST='true', ) self.assertEqual(response.status_code, 200) task.refresh_from_db() self.assertFalse(task.is_active) self.assertContains(response, 'Paused') self.assertContains(response, f'id="task-{task.pk}"') def test_form_only_offers_top_level_tasks_as_parents(self): parent = self.create_task('Parent') child = self.create_task('Child') child.parent_task = parent child.save() response = self.client.get(reverse('planner:task-create')) choices = response.context['form'].fields['parent_task'].queryset self.assertIn(parent, choices) self.assertNotIn(child, choices) def test_existing_category_is_selected_case_insensitively(self): Task.objects.create( owner=self.user, title="Existing cleaning", category="Cleaning", scheduled_for=date(2026, 10, 5), ) self.client.post(reverse("planner:task-create"), self.task_data(category=" cleaning ")) created = Task.objects.get(owner=self.user, title="Write project notes") self.assertEqual(created.category, "Cleaning") def test_new_category_is_trimmed_when_the_task_is_saved(self): self.client.post(reverse("planner:task-create"), self.task_data(category=" Home maintenance ")) created = Task.objects.get(owner=self.user, title="Write project notes") self.assertEqual(created.category, "Home maintenance") def test_editing_a_category_to_blank_only_clears_that_task(self): task = Task.objects.create( owner=self.user, title="Clear this category", category="Cleaning", scheduled_for=date(2026, 10, 5), ) other_task = Task.objects.create( owner=self.user, title="Keep this category", category="Cleaning", scheduled_for=date(2026, 10, 5), ) self.client.post( reverse("planner:task-update", args=[task.pk]), self.task_data(title=task.title, category="", is_recurring="", recurrence_unit=""), ) task.refresh_from_db() other_task.refresh_from_db() self.assertEqual(task.category, "") self.assertEqual(other_task.category, "Cleaning") def test_category_suggestions_are_private_and_deduplicated(self): other_user = get_user_model().objects.create_user(username="other-category-owner", password="password") Task.objects.create( owner=self.user, title="Cleaning one", category="Cleaning", scheduled_for=date(2026, 10, 5), ) Task.objects.create( owner=self.user, title="Cleaning two", category="cleaning", scheduled_for=date(2026, 10, 5), ) Task.objects.create( owner=other_user, title="Private category", category="Cleaning confidential", scheduled_for=date(2026, 10, 5), ) response = self.client.get(reverse("planner:category-suggestions"), {"q": "clean"}) self.assertEqual(response.status_code, 200) self.assertEqual(response.json(), {"categories": ["Cleaning"]}) def test_category_field_includes_accessible_picker_and_clear_control(self): task = Task.objects.create( owner=self.user, title="Categorised task", category="Cleaning", scheduled_for=date(2026, 10, 5), ) response = self.client.get(reverse("planner:task-update", args=[task.pk])) self.assertContains(response, "data-category-input") self.assertContains(response, "role=\"combobox\"") self.assertContains(response, "data-category-clear") self.assertContains(response, "aria-label=\"Clear category\"") class SchedulingServiceTests(TestCase): anchor = date(2026, 1, 5) def make_task(self, title, **overrides): defaults = {'scheduled_for': self.anchor} defaults.update(overrides) return Task.objects.create(title=title, **defaults) def test_one_time_task_is_only_eligible_on_its_scheduled_date(self): task = self.make_task('Appointment') self.assertTrue(is_task_eligible(task, self.anchor)) self.assertFalse(is_task_eligible(task, date(2026, 1, 6))) def test_daily_recurrence_uses_scheduled_date_as_anchor(self): task = self.make_task( 'Daily review', is_recurring=True, recurrence_interval=1, recurrence_unit=Task.RecurrenceUnit.DAY, ) self.assertTrue(is_task_eligible(task, self.anchor)) self.assertTrue(is_task_eligible(task, date(2026, 1, 6))) def test_daily_recurrence_honours_intervals_greater_than_one(self): task = self.make_task( 'Alternate days', is_recurring=True, recurrence_interval=2, recurrence_unit=Task.RecurrenceUnit.DAY, ) self.assertTrue(is_task_eligible(task, date(2026, 1, 7))) self.assertFalse(is_task_eligible(task, date(2026, 1, 6))) def test_weekly_recurrence_honours_intervals_greater_than_one(self): task = self.make_task( 'Fortnightly planning', is_recurring=True, recurrence_interval=2, recurrence_unit=Task.RecurrenceUnit.WEEK, ) self.assertTrue(is_task_eligible(task, date(2026, 1, 19))) self.assertFalse(is_task_eligible(task, date(2026, 1, 12))) def test_monthly_recurrence_retains_anchor_day_and_interval(self): task = self.make_task( 'Monthly close', scheduled_for=date(2026, 1, 31), is_recurring=True, recurrence_interval=2, recurrence_unit=Task.RecurrenceUnit.MONTH, ) self.assertTrue(is_task_eligible(task, date(2026, 3, 31))) self.assertFalse(is_task_eligible(task, date(2026, 2, 28))) self.assertFalse(is_task_eligible(task, date(2026, 4, 30))) def test_dates_before_recurrence_anchor_are_not_eligible(self): task = self.make_task( 'Daily review', is_recurring=True, recurrence_interval=1, recurrence_unit=Task.RecurrenceUnit.DAY, ) self.assertFalse(is_task_eligible(task, date(2026, 1, 4))) def test_invalid_recurrence_configuration_is_not_eligible(self): task = self.make_task( 'Broken repeat', is_recurring=True, recurrence_interval=0, recurrence_unit=Task.RecurrenceUnit.DAY, ) missing_unit = self.make_task('Missing unit', is_recurring=True, recurrence_unit='') self.assertFalse(is_task_eligible(task, self.anchor)) self.assertFalse(is_task_eligible(missing_unit, self.anchor)) def test_energy_levels_are_normalized_and_mapped_to_duration_budgets(self): self.assertEqual(normalize_energy_level(-3), 1) self.assertEqual(normalize_energy_level(8), 5) self.assertEqual(normalize_energy_level('not a number'), 3) self.assertEqual(duration_budget_for_energy(1), 15) self.assertEqual(duration_budget_for_energy(2), 30) self.assertEqual(duration_budget_for_energy(3), 60) self.assertEqual(duration_budget_for_energy(4), 90) self.assertEqual(duration_budget_for_energy(5), 180) def test_low_energy_prefers_shorter_fitting_tasks(self): short = self.make_task('Short', estimated_duration_minutes=10) long = self.make_task('Long', estimated_duration_minutes=20) unknown = self.make_task('Unknown') recommendations = recommend_tasks([unknown, long, short], self.anchor, 1) self.assertEqual([group.task.title for group in recommendations], ['Short', 'Long', 'Unknown']) def test_higher_energy_prefers_effective_duration_matches(self): small = self.make_task('Small', estimated_duration_minutes=30) useful = self.make_task('Useful', estimated_duration_minutes=80) over_budget = self.make_task('Over budget', estimated_duration_minutes=120) recommendations = recommend_tasks([small, over_budget, useful], self.anchor, 4) self.assertEqual( [group.task.title for group in recommendations], ['Useful', 'Small', 'Over budget'], ) def test_title_is_the_stable_final_recommendation_tie_breaker(self): zebra = self.make_task('Zebra', estimated_duration_minutes=15) alpha = self.make_task('Alpha', estimated_duration_minutes=15) recommendations = recommend_tasks([zebra, alpha], self.anchor, 1) self.assertEqual([group.task.title for group in recommendations], ['Alpha', 'Zebra']) def test_unknown_durations_remain_possible_but_rank_after_known_work(self): known = self.make_task('Known', estimated_duration_minutes=20) unknown = self.make_task('Unknown') recommendations = recommend_tasks([unknown, known], self.anchor, 2) self.assertEqual([group.task.title for group in recommendations], ['Known', 'Unknown']) def test_active_and_recurring_tasks_rank_first_when_otherwise_comparable(self): inactive = self.make_task('A inactive', is_active=False, estimated_duration_minutes=15) one_time = self.make_task('B one time', estimated_duration_minutes=15) recurring = self.make_task( 'C recurring', is_recurring=True, recurrence_interval=1, recurrence_unit=Task.RecurrenceUnit.DAY, estimated_duration_minutes=15, ) recommendations = recommend_tasks([inactive, one_time, recurring], self.anchor, 1) self.assertEqual( [group.task.title for group in recommendations], ['C recurring', 'B one time', 'A inactive'], ) def test_subtasks_are_locked_until_the_parent_is_completed(self): parent = self.make_task('Wash clothes') eligible_subtask = self.make_task('Fold clothes', parent_task=parent) self.make_task('Different day child', parent_task=parent, scheduled_for=date(2026, 1, 6)) top_level_tasks = Task.objects.filter(parent_task__isnull=True).prefetch_related('subtasks') recommendations = recommend_tasks(top_level_tasks, self.anchor, 3) self.assertEqual([group.task.title for group in recommendations], ['Wash clothes']) self.assertEqual(recommendations[0].subtasks, ()) parent.is_completed = True parent.save(update_fields=['is_completed']) top_level_tasks = Task.objects.filter(parent_task__isnull=True).prefetch_related('subtasks') recommendations = recommend_tasks(top_level_tasks, self.anchor, 3) self.assertEqual([group.task.title for group in recommendations], [eligible_subtask.title]) self.assertEqual(recommendations[0].subtasks, ()) class DailyPlannerViewTests(TestCase): def test_daily_planner_applies_authenticated_users_sick_day_settings(self): user = get_user_model().objects.create_user(username='sick-user', password='password') SickDaySettings.objects.create( user=user, enabled=True, recovery_date=date(2026, 10, 8), ) Task.objects.create(owner=user, title='Ordinary task', scheduled_for=date(2026, 10, 5)) Task.objects.create( owner=user, title='Required task', scheduled_for=date(2026, 10, 5), required_on_sick_day=True, ) self.client.force_login(user) response = self.client.get( reverse('planner:daily-planner'), {'selected_date': '2026-10-05', 'energy_level': '3'}, ) self.assertNotContains(response, 'Ordinary task') self.assertContains(response, 'Required task') def test_daily_planner_renders_service_recommendations(self): user = get_user_model().objects.create_user(username='daily-user', password='password') self.client.force_login(user) Task.objects.create(owner=user, title='Today task', scheduled_for=date(2026, 10, 5)) response = self.client.get( reverse('planner:daily-planner'), {'selected_date': '2026-10-05', 'energy_level': '3'}, ) self.assertEqual(response.status_code, 200) self.assertContains(response, 'Today task') self.assertContains(response, 'Your available time:') class DeferralServiceTests(TestCase): selected_date = date(2026, 10, 6) def make_task(self, title='Task', **overrides): defaults = {'scheduled_for': self.selected_date} defaults.update(overrides) return Task.objects.create(title=title, **defaults) def make_sick_day_settings(self, **overrides): user = get_user_model().objects.create_user(username='planner-user') defaults = {'enabled': True, 'recovery_date': date(2026, 10, 8)} defaults.update(overrides) return SickDaySettings.objects.create(user=user, **defaults) def test_deferral_hides_before_target_and_makes_one_time_task_eligible_on_target(self): task = self.make_task(scheduled_for=date(2026, 10, 1)) defer_task_manually(task, date(2026, 10, 6)) self.assertFalse(is_task_eligible(task, date(2026, 10, 5))) self.assertTrue(is_task_eligible(task, date(2026, 10, 6))) self.assertFalse(is_task_eligible(task, date(2026, 10, 7))) def test_manual_deferral_can_extend_but_never_silently_shorten(self): task = self.make_task() self.assertTrue(defer_task_manually(task, date(2026, 10, 10))) self.assertFalse(defer_task_manually(task, date(2026, 10, 8))) task.refresh_from_db() self.assertEqual(task.deferred_until, date(2026, 10, 10)) self.assertEqual(task.deferral_source, Task.DeferralSource.MANUAL) def test_missed_one_time_task_gets_deferral_relative_to_viewed_date(self): task = self.make_task(scheduled_for=date(2026, 10, 1), defer_days=3) changed = apply_missed_task_deferrals([task], self.selected_date) task.refresh_from_db() self.assertEqual(changed, [task]) self.assertEqual(task.deferred_until, date(2026, 10, 9)) self.assertEqual(task.deferral_source, Task.DeferralSource.MISSED) self.assertTrue(is_task_eligible(task, date(2026, 10, 9))) def test_missed_deferral_never_applies_to_recurring_task_or_overwrites_manual_one(self): recurring = self.make_task( 'Recurring', scheduled_for=date(2026, 10, 1), defer_days=3, is_recurring=True, recurrence_interval=1, recurrence_unit=Task.RecurrenceUnit.DAY, ) manual = self.make_task('Manual', scheduled_for=date(2026, 10, 1), defer_days=3) defer_task_manually(manual, date(2026, 10, 12)) apply_missed_task_deferrals([recurring, manual], self.selected_date) recurring.refresh_from_db() manual.refresh_from_db() self.assertIsNone(recurring.deferred_until) self.assertEqual(manual.deferred_until, date(2026, 10, 12)) self.assertEqual(manual.deferral_source, Task.DeferralSource.MANUAL) def test_sick_day_defers_normally_scheduled_work_but_keeps_required_work_eligible(self): settings = self.make_sick_day_settings() ordinary = self.make_task('Ordinary') required = self.make_task('Required', required_on_sick_day=True) sync_sick_day_deferrals([ordinary, required], settings, self.selected_date) ordinary.refresh_from_db() required.refresh_from_db() self.assertEqual(ordinary.deferred_until, date(2026, 10, 9)) self.assertEqual(ordinary.deferral_source, Task.DeferralSource.SICK_DAY) self.assertFalse(is_task_eligible(ordinary, self.selected_date)) self.assertIsNone(required.deferred_until) self.assertTrue(is_task_eligible(required, self.selected_date)) def test_sick_day_without_recovery_defers_relative_to_viewed_date(self): settings = self.make_sick_day_settings(recovery_date=None) task = self.make_task() sync_sick_day_deferrals([task], settings, self.selected_date) task.refresh_from_db() self.assertEqual(task.deferred_until, self.selected_date + timedelta(days=1)) def test_sick_day_only_modifies_its_own_deferrals(self): settings = self.make_sick_day_settings() manual = self.make_task('Manual', deferred_until=date(2026, 10, 12), deferral_source=Task.DeferralSource.MANUAL) missed = self.make_task('Missed', deferred_until=date(2026, 10, 11), deferral_source=Task.DeferralSource.MISSED) sick_day = self.make_task('Sick day', deferred_until=date(2026, 10, 9), deferral_source=Task.DeferralSource.SICK_DAY) sync_sick_day_deferrals([manual, missed, sick_day], settings, self.selected_date) settings.enabled = False settings.save() sync_sick_day_deferrals([manual, missed, sick_day], settings, self.selected_date) manual.refresh_from_db() missed.refresh_from_db() sick_day.refresh_from_db() self.assertEqual(manual.deferred_until, date(2026, 10, 12)) self.assertEqual(manual.deferral_source, Task.DeferralSource.MANUAL) self.assertEqual(missed.deferred_until, date(2026, 10, 11)) self.assertEqual(missed.deferral_source, Task.DeferralSource.MISSED) self.assertIsNone(sick_day.deferred_until) self.assertEqual(sick_day.deferral_source, '') def test_recovery_date_change_can_move_sick_day_deferral_earlier_or_later(self): settings = self.make_sick_day_settings(recovery_date=date(2026, 10, 8)) task = self.make_task() sync_sick_day_deferrals([task], settings, self.selected_date) settings.recovery_date = date(2026, 10, 15) settings.save() sync_sick_day_deferrals([task], settings, self.selected_date) task.refresh_from_db() self.assertEqual(task.deferred_until, date(2026, 10, 16)) settings.recovery_date = date(2026, 10, 7) settings.save() sync_sick_day_deferrals([task], settings, self.selected_date) task.refresh_from_db() self.assertEqual(task.deferred_until, date(2026, 10, 8)) def test_daily_recommendations_combine_recurrence_missed_manual_and_sick_day_policy(self): settings = self.make_sick_day_settings() recurring = self.make_task( 'Recurring work', scheduled_for=date(2026, 10, 1), defer_days=2, is_recurring=True, recurrence_interval=1, recurrence_unit=Task.RecurrenceUnit.DAY, ) overdue = self.make_task('Overdue work', scheduled_for=date(2026, 10, 1), defer_days=2) manual = self.make_task('Manual work') defer_task_manually(manual, date(2026, 10, 12)) recommendations = daily_recommendations(self.selected_date, 3, settings) recurring.refresh_from_db() overdue.refresh_from_db() manual.refresh_from_db() self.assertEqual(recommendations, []) self.assertEqual(recurring.deferral_source, Task.DeferralSource.SICK_DAY) self.assertEqual(recurring.deferred_until, date(2026, 10, 9)) self.assertEqual(overdue.deferral_source, Task.DeferralSource.MISSED) self.assertEqual(overdue.deferred_until, date(2026, 10, 8)) self.assertEqual(manual.deferral_source, Task.DeferralSource.MANUAL) self.assertEqual(manual.deferred_until, date(2026, 10, 12)) class FastingServiceTests(TestCase): def make_user(self, username='faster'): return get_user_model().objects.create_user(username=username, password='password') def aware(self, year, month, day, hour, minute=0): return timezone.make_aware(datetime(year, month, day, hour, minute), timezone.get_current_timezone()) def make_settings(self, **overrides): defaults = { 'user': self.make_user(), 'enabled': True, 'fasting_start_time': time(20, 0), 'fasting_duration_minutes': 16 * 60, 'tracking_started_at': self.aware(2026, 10, 1, 19), } defaults.update(overrides) return FastingSettings.objects.create(**defaults) def test_duration_display_uses_hours_and_remaining_minutes(self): self.assertEqual(duration_as_hours_and_minutes(16 * 60), "16 hours") self.assertEqual(duration_as_hours_and_minutes(90), "1 hour 30 min") def test_current_phase_is_calculated_from_daily_schedule_across_midnight(self): settings = self.make_settings() fasting = current_fasting_phase(settings, self.aware(2026, 10, 2, 11)) eating = current_fasting_phase(settings, self.aware(2026, 10, 2, 12)) self.assertTrue(fasting.is_fasting) self.assertEqual(fasting.scheduled_end, self.aware(2026, 10, 2, 12)) self.assertFalse(eating.is_fasting) def test_fasting_form_offers_standard_daily_fasting_presets(self): form = FastingSettingsForm() duration_field = form.fields['fasting_duration_minutes'] self.assertEqual(duration_field.label, 'Daily fasting schedule') self.assertEqual(duration_field.choices[0][0], 'Beginner') self.assertIn((12 * 60, '12:12 — Fast 12 hours, eat within 12 hours'), duration_field.choices[0][1]) self.assertTrue(FastingSettingsForm({ 'enabled': 'on', 'fasting_start_time': '20:00', 'fasting_duration_minutes': str(16 * 60), }).is_valid()) def test_eating_cycle_runs_from_fasting_end_to_next_fasting_start(self): settings = self.make_settings() phase = current_fasting_phase(settings, self.aware(2026, 10, 2, 13)) self.assertFalse(phase.is_fasting) self.assertEqual(phase.cycle_start, self.aware(2026, 10, 2, 12)) self.assertEqual(phase.cycle_end, self.aware(2026, 10, 2, 20)) def test_arbitrary_valid_duration_is_supported_and_invalid_duration_is_rejected(self): user = self.make_user() settings = configure_fasting( user, enabled=True, fasting_start_time=time(6, 30), fasting_duration_minutes=93, now=self.aware(2026, 10, 1, 6), ) phase = current_fasting_phase(settings, self.aware(2026, 10, 1, 7)) self.assertTrue(phase.is_fasting) self.assertEqual(phase.scheduled_end, self.aware(2026, 10, 1, 8, 3)) self.assertFalse(FastingSettingsForm({'enabled': 'on', 'fasting_start_time': '20:00', 'fasting_duration_minutes': '1440'}).is_valid()) def test_initial_configuration_does_not_backfill_a_period_already_in_progress(self): settings = self.make_settings(tracking_started_at=self.aware(2026, 10, 1, 21)) synchronize_fasting_periods(settings, self.aware(2026, 10, 3, 13)) starts = list(FastingPeriod.objects.values_list('scheduled_start', flat=True)) self.assertEqual(starts, [self.aware(2026, 10, 2, 20)]) def test_synchronization_creates_each_completed_period_once(self): settings = self.make_settings() now = self.aware(2026, 10, 3, 13) created = synchronize_fasting_periods(settings, now) repeated = synchronize_fasting_periods(settings, now) self.assertEqual(len(created), 2) self.assertEqual(repeated, []) self.assertEqual(FastingPeriod.objects.filter(user=settings.user).count(), 2) self.assertEqual( FastingPeriod.objects.filter(user=settings.user).values_list('status', flat=True).distinct().get(), FastingPeriod.Status.COMPLETED, ) def test_paused_interval_never_generates_history_and_resume_uses_normal_schedule(self): settings = self.make_settings() paused_at = self.aware(2026, 10, 1, 22) settings = set_fasting_tracking_enabled(settings, False, paused_at) self.assertEqual(synchronize_fasting_periods(settings, self.aware(2026, 10, 3, 13)), []) self.assertEqual(FastingPeriod.objects.count(), 0) self.assertEqual(FastingPause.objects.filter(user=settings.user, resumed_at__isnull=True).count(), 1) settings = set_fasting_tracking_enabled(settings, True, self.aware(2026, 10, 3, 19)) synchronize_fasting_periods(settings, self.aware(2026, 10, 5, 13)) starts = list(FastingPeriod.objects.values_list('scheduled_start', flat=True)) self.assertEqual(len(starts), 2) self.assertIn(self.aware(2026, 10, 3, 20), starts) self.assertIn(self.aware(2026, 10, 4, 20), starts) self.assertNotIn(self.aware(2026, 10, 1, 20), starts) def test_pause_preserves_existing_history(self): settings = self.make_settings() synchronize_fasting_periods(settings, self.aware(2026, 10, 2, 13)) existing_count = FastingPeriod.objects.count() settings = set_fasting_tracking_enabled(settings, False, self.aware(2026, 10, 2, 14)) synchronize_fasting_periods(settings, self.aware(2026, 10, 5, 13)) self.assertEqual(FastingPeriod.objects.count(), existing_count) class FastingWidgetViewTests(TestCase): def setUp(self): self.user = get_user_model().objects.create_user(username='widget-user', password='password') self.client.force_login(self.user) def test_unconfigured_user_sees_unobtrusive_setup_widget(self): response = self.client.get(reverse('planner:task-list')) self.assertContains(response, 'Set up fasting') self.assertNotContains(response, 'Fasting now') def test_htmx_configuration_creates_enabled_settings(self): response = self.client.post( reverse('planner:fasting-configure'), { 'enabled': 'on', 'fasting_start_time': '20:00', 'fasting_duration_minutes': '960', }, HTTP_HX_REQUEST='true', ) self.assertEqual(response.status_code, 200) settings = FastingSettings.objects.get(user=self.user) self.assertTrue(settings.enabled) self.assertEqual(settings.fasting_duration_minutes, 960) self.assertContains(response, 'Pause tracking') self.assertContains(response, 'Daily fast') self.assertContains(response, '16 hours') self.assertContains(response, 'window') self.assertNotContains(response, '960 min') def test_htmx_pause_marks_tracking_paused(self): FastingSettings.objects.create( user=self.user, enabled=True, fasting_start_time=time(20), fasting_duration_minutes=960, tracking_started_at=timezone.now(), ) response = self.client.post(reverse('planner:fasting-toggle'), HTTP_HX_REQUEST='true') self.assertEqual(response.status_code, 200) self.assertFalse(FastingSettings.objects.get(user=self.user).enabled) self.assertContains(response, 'Tracking paused') from decimal import Decimal from unittest.mock import patch from django.core.cache import cache from .models import TaskWeatherShift, UserSettings from .services.weather import ( DailyForecast, WeatherServiceError, evaluate_weather_suitability, forecast_for_user_on_date, forecasts_for_user, normalize_open_meteo_response, wmo_condition, ) class AuthenticationAndOwnershipTests(TestCase): def setUp(self): self.user_a = get_user_model().objects.create_user(username='owner-a', password='strong-pass-123') self.user_b = get_user_model().objects.create_user(username='owner-b', password='strong-pass-123') def test_anonymous_visitors_are_redirected_to_login(self): for name in ('task-list', 'daily-planner', 'user-settings', 'fasting-widget'): response = self.client.get(reverse(f'planner:{name}')) self.assertEqual(response.status_code, 302) self.assertIn('/login/', response['Location']) def test_registration_creates_a_normal_logged_in_user(self): response = self.client.post(reverse('planner:register'), { 'username': 'new-person', 'password1': 'complex-pass-123', 'password2': 'complex-pass-123', }) user = get_user_model().objects.get(username='new-person') self.assertRedirects(response, reverse('planner:task-list')) self.assertFalse(user.is_staff) self.assertFalse(user.is_superuser) self.assertEqual(int(self.client.session['_auth_user_id']), user.pk) def test_login_and_post_logout_work(self): response = self.client.post(reverse('planner:login'), {'username': 'owner-a', 'password': 'strong-pass-123'}) self.assertRedirects(response, reverse('planner:task-list')) response = self.client.post(reverse('planner:logout')) self.assertRedirects(response, reverse('planner:login')) def test_new_tasks_are_owned_by_the_request_user_and_private(self): theirs = Task.objects.create(owner=self.user_b, title='Private task', scheduled_for=date(2026, 10, 5)) self.client.force_login(self.user_a) response = self.client.post(reverse('planner:task-create'), { 'title': 'Mine', 'scheduled_for': '2026-10-05', 'priority': 'medium', 'weather_profile': 'none', 'recurrence_interval': '1', }) mine = Task.objects.get(title='Mine') self.assertEqual(mine.owner, self.user_a) self.assertEqual(self.client.get(reverse('planner:task-detail', args=[theirs.pk])).status_code, 404) self.assertEqual(self.client.get(reverse('planner:task-update', args=[theirs.pk])).status_code, 404) self.assertEqual(self.client.post(reverse('planner:task-delete', args=[theirs.pk])).status_code, 404) self.assertNotContains(self.client.get(reverse('planner:task-list')), 'Private task') def test_recommendations_and_parent_choices_are_owner_scoped(self): foreign_parent = Task.objects.create(owner=self.user_b, title='Foreign parent', scheduled_for=date(2026, 10, 5)) Task.objects.create(owner=self.user_b, title='Foreign recommendation', scheduled_for=date(2026, 10, 5)) Task.objects.create(owner=self.user_a, title='Own recommendation', scheduled_for=date(2026, 10, 5)) self.client.force_login(self.user_a) response = self.client.get(reverse('planner:daily-planner'), {'selected_date': '2026-10-05', 'energy_level': '3'}) self.assertContains(response, 'Own recommendation') self.assertNotContains(response, 'Foreign recommendation') response = self.client.get(reverse('planner:task-create')) self.assertNotIn(foreign_parent, response.context['form'].fields['parent_task'].queryset) def test_cross_user_parent_relationship_is_rejected(self): foreign_parent = Task.objects.create(owner=self.user_b, title='Foreign parent', scheduled_for=date(2026, 10, 5)) child = Task(owner=self.user_a, title='Child', scheduled_for=date(2026, 10, 5), parent_task=foreign_parent) with self.assertRaises(ValidationError): child.full_clean() class UserSettingsTests(TestCase): def setUp(self): self.user_a = get_user_model().objects.create_user(username='settings-a', password='password') self.user_b = get_user_model().objects.create_user(username='settings-b', password='password') self.client.force_login(self.user_a) def test_location_and_sick_day_settings_are_independent_per_user(self): response = self.client.post(reverse('planner:user-settings'), { 'section': 'location', 'latitude': '52.956532', 'longitude': '5.926220', }) self.assertRedirects(response, reverse('planner:user-settings')) settings_a = UserSettings.objects.get(user=self.user_a) self.assertEqual(settings_a.latitude, Decimal('52.956532')) self.assertFalse(UserSettings.objects.filter(user=self.user_b).exists()) self.client.post(reverse('planner:user-settings'), { 'section': 'sick-day', 'enabled': 'on', 'recovery_date': '2026-10-08', }) self.assertTrue(SickDaySettings.objects.get(user=self.user_a).enabled) self.assertFalse(SickDaySettings.objects.filter(user=self.user_b).exists()) def test_location_fields_are_text_inputs_for_reliable_decimal_pasting(self): response = self.client.get(reverse('planner:user-settings')) self.assertEqual(response.context['profile_form'].fields['latitude'].widget.input_type, 'text') self.assertEqual(response.context['profile_form'].fields['longitude'].widget.input_type, 'text') def test_location_validation_rejects_out_of_range_or_partial_coordinates(self): response = self.client.post(reverse('planner:user-settings'), { 'section': 'location', 'latitude': '91', 'longitude': '4.9', }) self.assertEqual(response.status_code, 200) response = self.client.post(reverse('planner:user-settings'), { 'section': 'location', 'latitude': '52.3', 'longitude': '', }) self.assertEqual(response.status_code, 200) self.assertFalse(UserSettings.objects.filter(user=self.user_a, latitude__isnull=False).exists()) def test_time_zone_setting_is_saved_separately_from_location(self): response = self.client.post(reverse("planner:user-settings"), { "section": "time-zone", "time_zone": "UTC", }) self.assertEqual(response.status_code, 302) self.assertEqual(UserSettings.objects.get(user=self.user_a).time_zone, "UTC") self.assertFalse(UserSettings.objects.filter(user=self.user_b).exists()) def test_appearance_is_saved_per_user_and_applied_to_the_page(self): response = self.client.post(reverse("planner:user-settings"), { "section": "appearance", "appearance": UserSettings.Appearance.DARK, "next": reverse("planner:task-list"), }) self.assertRedirects(response, reverse("planner:task-list")) self.assertEqual( UserSettings.objects.get(user=self.user_a).appearance, UserSettings.Appearance.DARK ) page = self.client.get(reverse("planner:task-list")) self.assertContains(page, "data-theme=\"dark\"") self.client.force_login(self.user_b) self.client.post(reverse("planner:user-settings"), { "section": "appearance", "appearance": UserSettings.Appearance.LIGHT, "next": reverse("planner:task-list"), }) self.assertEqual( UserSettings.objects.get(user=self.user_a).appearance, UserSettings.Appearance.DARK ) self.assertEqual( UserSettings.objects.get(user=self.user_b).appearance, UserSettings.Appearance.LIGHT ) class OnboardingTests(TestCase): def setUp(self): self.user = get_user_model().objects.create_user(username="new-tour-user", password="password") self.other = get_user_model().objects.create_user(username="other-tour-user", password="password") self.client.force_login(self.user) def test_new_user_sees_first_step_and_next_moves_to_the_next_component(self): response = self.client.get(reverse("planner:task-list")) self.assertContains(response, "Getting started · 1 of 6") self.assertContains(response, "Start with one clear task") profile = UserSettings.objects.get(user=self.user) self.assertTrue(profile.onboarding_enabled) self.assertEqual(profile.onboarding_step, 0) response = self.client.post(reverse("planner:onboarding-advance"), {"action": "next"}) self.assertRedirects(response, reverse("planner:task-list")) profile.refresh_from_db() self.assertEqual(profile.onboarding_step, 1) page = self.client.get(reverse("planner:task-list")) self.assertContains(page, "Use the Daily planner for a realistic next step") self.assertContains(page, "daily-planner-nav") def test_tour_can_be_disabled_or_restarted_without_affecting_other_users(self): self.client.get(reverse("planner:task-list")) other_profile = UserSettings.objects.create( user=self.other, onboarding_enabled=True, onboarding_step=3 ) self.client.post(reverse("planner:onboarding-advance"), {"action": "skip"}) profile = UserSettings.objects.get(user=self.user) self.assertFalse(profile.onboarding_enabled) self.assertNotContains(self.client.get(reverse("planner:task-list")), "Getting started") response = self.client.post(reverse("planner:user-settings"), { "section": "onboarding", "action": "restart", }) self.assertRedirects(response, reverse("planner:task-list")) profile.refresh_from_db() other_profile.refresh_from_db() self.assertTrue(profile.onboarding_enabled) self.assertEqual(profile.onboarding_step, 0) self.assertEqual((other_profile.onboarding_enabled, other_profile.onboarding_step), (True, 3)) self.client.post(reverse("planner:user-settings"), { "section": "onboarding", "action": "disable", }) profile.refresh_from_db() self.assertFalse(profile.onboarding_enabled) class DemoSeedCommandTests(TestCase): def test_command_creates_and_repeatedly_restores_only_the_demo_account(self): other = get_user_model().objects.create_user(username="private-user", password="password") private_task = Task.objects.create( owner=other, title="Private task", scheduled_for=timezone.localdate() ) call_command("seed_demo") demo = get_user_model().objects.get(username="demo") self.assertTrue(demo.check_password("demo")) self.assertEqual(Task.objects.filter(owner=demo).count(), 5) self.assertEqual(Workout.objects.filter(owner=demo).count(), 2) self.assertEqual(NeckHeadacheCheckIn.objects.filter(user=demo).count(), 4) self.assertEqual(SleepCheckIn.objects.filter(user=demo).count(), 4) self.assertTrue(FastingSettings.objects.get(user=demo).enabled) profile = UserSettings.objects.get(user=demo) self.assertEqual(profile.time_zone, "Europe/Amsterdam") self.assertFalse(profile.onboarding_enabled) self.assertTrue(Task.objects.filter(owner=demo, title="Fold the clothes", parent_task__isnull=False).exists()) Task.objects.create(owner=demo, title="Temporary demo edit", scheduled_for=timezone.localdate()) call_command("seed_demo") self.assertEqual(Task.objects.filter(owner=demo).count(), 5) self.assertFalse(Task.objects.filter(owner=demo, title="Temporary demo edit").exists()) self.assertTrue(Task.objects.filter(pk=private_task.pk, owner=other).exists()) class UserTimeZoneTests(TestCase): def test_default_is_europe_amsterdam_and_fasting_uses_the_saved_zone(self): user = get_user_model().objects.create_user(username="timezone-user", password="password") profile = UserSettings.objects.create(user=user, time_zone="UTC") fasting = FastingSettings.objects.create( user=user, enabled=True, fasting_start_time=time(20, 0), fasting_duration_minutes=16 * 60, ) now = datetime(2026, 10, 2, 20, 30, tzinfo=ZoneInfo("UTC")) phase = current_fasting_phase(fasting, now) self.assertEqual(profile.time_zone, "UTC") self.assertTrue(phase.is_fasting) self.assertEqual(phase.scheduled_start.tzinfo, ZoneInfo("UTC")) class WeatherServiceTests(TestCase): def setUp(self): self.user = get_user_model().objects.create_user(username='weather-user', password='password') self.task = Task.objects.create(owner=self.user, title='Garden', scheduled_for=date(2026, 10, 5)) self.dry = DailyForecast(date(2026, 10, 5), 'clear', 5, 0, 8, 19, 12, 20000) self.rain = DailyForecast(date(2026, 10, 5), 'rain', 80, 3, 8, 14, 12, 0) def test_normalization_and_wmo_mapping(self): forecasts = normalize_open_meteo_response({'daily': { 'time': ['2026-10-05'], 'weather_code': [63], 'precipitation_probability_max': [70], 'precipitation_sum': [2.5], 'temperature_2m_min': [8], 'temperature_2m_max': [14], 'wind_speed_10m_max': [22], 'sunshine_duration': [0], }}) self.assertEqual(forecasts[0].condition, 'rain') self.assertEqual(forecasts[0].temperature_max_c, 14.0) self.assertEqual(wmo_condition(95), 'thunderstorm') self.assertEqual(wmo_condition(71), 'snow') def test_cache_avoids_repeated_open_meteo_calls_and_failure_is_graceful(self): UserSettings.objects.create(user=self.user, latitude='52.36760', longitude='4.90410') cache.clear() with patch('planner.services.weather.fetch_open_meteo_forecasts', return_value=[self.dry]) as fetch: self.assertEqual(forecast_for_user_on_date(self.user, self.dry.forecast_date), self.dry) self.assertEqual(forecast_for_user_on_date(self.user, self.dry.forecast_date), self.dry) fetch.assert_called_once() cache.clear() with patch('planner.services.weather.fetch_open_meteo_forecasts', side_effect=WeatherServiceError): self.assertIsNone(forecasts_for_user(self.user)) def test_suitability_profiles_and_unknown_forecast(self): self.task.weather_profile = Task.WeatherProfile.DRY self.assertEqual(evaluate_weather_suitability(self.task, self.dry).status, 'suitable') self.assertEqual(evaluate_weather_suitability(self.task, self.rain).status, 'unsuitable') self.task.weather_profile = Task.WeatherProfile.SUNNY self.assertEqual(evaluate_weather_suitability(self.task, self.dry).status, 'suitable') self.task.weather_profile = Task.WeatherProfile.WARM self.assertEqual(evaluate_weather_suitability(self.task, self.rain).status, 'unsuitable') self.task.weather_profile = Task.WeatherProfile.DRY_AND_WARM self.assertEqual(evaluate_weather_suitability(self.task, self.dry).status, 'suitable') self.assertEqual(evaluate_weather_suitability(self.task, None).status, 'unknown') class WeatherSchedulingTests(TestCase): monday = date(2026, 10, 5) def setUp(self): self.user = get_user_model().objects.create_user(username='weather-schedule', password='password') def forecast(self, day, *, rainy=False): return DailyForecast(day, 'rain' if rainy else 'clear', 80 if rainy else 0, 2 if rainy else 0, 8, 18, 10, 0 if rainy else 20000) def test_unsuitable_occurrence_moves_without_changing_anchor_or_completion(self): task = Task.objects.create(owner=self.user, title='Paint fence', scheduled_for=self.monday, weather_profile=Task.WeatherProfile.DRY) days = {self.monday: self.forecast(self.monday, rainy=True), self.monday + timedelta(days=1): self.forecast(self.monday + timedelta(days=1), rainy=False)} with patch('planner.services.weather.forecast_for_user_on_date', side_effect=lambda _user, day: days.get(day)): self.assertEqual(daily_recommendations(self.user, self.monday, 3), []) shift = TaskWeatherShift.objects.get(task=task) self.assertEqual(shift.shifted_to, self.monday + timedelta(days=1)) groups = daily_recommendations(self.user, self.monday + timedelta(days=1), 3) self.assertEqual([group.task for group in groups], [task]) self.assertEqual(task.scheduled_for, self.monday) self.assertFalse(hasattr(task, 'completed_at')) def test_shift_skips_natural_recurrence_and_existing_shift_collisions(self): task = Task.objects.create(owner=self.user, title='Outdoor routine', scheduled_for=self.monday, is_recurring=True, recurrence_interval=2, recurrence_unit=Task.RecurrenceUnit.DAY, weather_profile=Task.WeatherProfile.DRY) # Monday moves past rainy Tuesday and natural Wednesday to dry Thursday. weather = {self.monday: self.forecast(self.monday, rainy=True), self.monday + timedelta(days=1): self.forecast(self.monday + timedelta(days=1), rainy=True), self.monday + timedelta(days=3): self.forecast(self.monday + timedelta(days=3))} with patch('planner.services.weather.forecast_for_user_on_date', side_effect=lambda _user, day: weather.get(day)): daily_recommendations(self.user, self.monday, 3) first = TaskWeatherShift.objects.get(task=task, original_date=self.monday) self.assertEqual(first.shifted_to, self.monday + timedelta(days=3)) # Wednesday's own rainy occurrence must move beyond Thursday's existing shift. weather[self.monday + timedelta(days=2)] = self.forecast(self.monday + timedelta(days=2), rainy=True) weather[self.monday + timedelta(days=5)] = self.forecast(self.monday + timedelta(days=5)) daily_recommendations(self.user, self.monday + timedelta(days=2), 3) second = TaskWeatherShift.objects.get(task=task, original_date=self.monday + timedelta(days=2)) self.assertEqual(second.shifted_to, self.monday + timedelta(days=5)) def test_no_suitable_date_is_safe_and_manual_or_sick_day_never_gets_overwritten(self): task = Task.objects.create(owner=self.user, title='Wait for dry', scheduled_for=self.monday, weather_profile=Task.WeatherProfile.DRY) with patch('planner.services.weather.forecast_for_user_on_date', return_value=self.forecast(self.monday, rainy=True)): daily_recommendations(self.user, self.monday, 3) self.assertIsNone(TaskWeatherShift.objects.get(task=task).shifted_to) manual = Task.objects.create(owner=self.user, title='Manual', scheduled_for=self.monday, weather_profile=Task.WeatherProfile.DRY, deferred_until=self.monday + timedelta(days=2), deferral_source=Task.DeferralSource.MANUAL) sick = SickDaySettings.objects.create(user=self.user, enabled=True, recovery_date=self.monday) with patch('planner.services.weather.forecast_for_user_on_date', return_value=self.forecast(self.monday, rainy=True)): daily_recommendations(self.user, self.monday, 3, sick) manual.refresh_from_db() self.assertEqual(manual.deferral_source, Task.DeferralSource.MANUAL) self.assertFalse(TaskWeatherShift.objects.filter(task=manual).exists()) class TaskForecastPresentationTests(TestCase): def setUp(self): self.user = get_user_model().objects.create_user(username='forecast-display', password='password') self.task = Task.objects.create( owner=self.user, title='Future walk', scheduled_for=timezone.localdate() + timedelta(days=1), ) self.forecast = DailyForecast( self.task.scheduled_for, 'clear', 5, 0, 9, 18, 10, 22000, ) self.client.force_login(self.user) @patch('planner.views.forecasts_for_user') def test_future_task_forecast_is_shown_on_list_and_detail(self, forecasts_for_user): forecasts_for_user.return_value = [self.forecast] response = self.client.get(reverse('planner:task-list')) self.assertContains(response, 'Forecast for this task: Clear, 18 °C') response = self.client.get(reverse('planner:task-detail', args=[self.task.pk])) self.assertContains(response, 'Predicted weather') self.assertContains(response, 'Clear, 18 °C') from .models import Workout, WorkoutCompletion from .services.workouts import toggle_workout_completion, workouts_for_day from .views import duration_as_hours_and_minutes class WorkoutServiceTests(TestCase): def setUp(self): self.user = get_user_model().objects.create_user(username='workout-user', password='password') self.today = date(2026, 10, 5) def test_daily_recurrence_completion_only_applies_to_that_day(self): workout = Workout.objects.create( owner=self.user, name='Morning walk', scheduled_for=self.today, is_daily_recurring=True, ) self.assertEqual([item.name for item in workouts_for_day(self.user, self.today).workouts], ['Morning walk']) self.assertTrue(toggle_workout_completion(workout, self.today)) self.assertTrue(workouts_for_day(self.user, self.today).workouts[0].completed_for_day) tomorrow = self.today + timedelta(days=1) self.assertFalse(workouts_for_day(self.user, tomorrow).workouts[0].completed_for_day) self.assertEqual(WorkoutCompletion.objects.count(), 1) def test_calorie_total_uses_completed_entries_with_calorie_data_only(self): Workout.objects.create(owner=self.user, name='Run', scheduled_for=self.today, is_completed=True, calories_burned=420) Workout.objects.create(owner=self.user, name='Stretch', scheduled_for=self.today, is_completed=True) Workout.objects.create(owner=self.user, name='Cycle', scheduled_for=self.today, is_completed=False, calories_burned=250) summary = workouts_for_day(self.user, self.today) self.assertEqual(summary.calories_total, 420) self.assertEqual(summary.completed_without_calories, 1) class WorkoutOwnershipViewTests(TestCase): def setUp(self): self.owner = get_user_model().objects.create_user(username='workout-owner', password='password') self.other = get_user_model().objects.create_user(username='other-workout-owner', password='password') self.client.force_login(self.owner) self.today = timezone.localdate() def test_creation_is_owned_and_other_users_cannot_mutate_or_see_workouts(self): foreign = Workout.objects.create(owner=self.other, name='Private run', scheduled_for=self.today) response = self.client.post(reverse('planner:workout-create'), { 'name': 'My yoga', 'scheduled_for': self.today.isoformat(), 'duration_minutes': '30', 'calories_burned': '100', }) mine = Workout.objects.get(name='My yoga') self.assertEqual(mine.owner, self.owner) self.assertEqual(response.status_code, 302) page = self.client.get(reverse('planner:task-list')) self.assertContains(page, 'My yoga') self.assertNotContains(page, 'Private run') self.assertEqual(self.client.post(reverse('planner:workout-toggle-completed', args=[foreign.pk])).status_code, 404) self.assertEqual(self.client.post(reverse('planner:workout-delete', args=[foreign.pk])).status_code, 404) self.assertEqual(self.client.get(reverse('planner:workout-update', args=[foreign.pk])).status_code, 404) def test_dashboard_completion_updates_daily_total(self): workout = Workout.objects.create(owner=self.owner, name='Swim', scheduled_for=self.today, calories_burned=300) response = self.client.post(reverse('planner:workout-toggle-completed', args=[workout.pk]), HTTP_HX_REQUEST='true') self.assertEqual(response.status_code, 200) self.assertContains(response, '300 kcal') workout.refresh_from_db() self.assertTrue(workout.is_completed) from .models import NeckHeadacheCheckIn, SleepCheckIn from .services.checkins import calculate_check_in_streaks class NeckHeadacheCheckInTests(TestCase): def setUp(self): self.user = get_user_model().objects.create_user(username='checkin-owner', password='password') self.other = get_user_model().objects.create_user(username='other-checkin-owner', password='password') self.client.force_login(self.user) self.today = timezone.localdate() def check_in(self, user, day, neck=0, headache=0, **kwargs): if "note" in kwargs: kwargs["morning_note"] = kwargs.pop("note") return NeckHeadacheCheckIn.objects.create( user=user, check_in_date=day, morning_neck_pain_severity=neck, morning_headache_severity=headache, afternoon_neck_pain_severity=neck, afternoon_headache_severity=headache, evening_neck_pain_severity=neck, evening_headache_severity=headache, **kwargs, ) def test_entries_are_scoped_to_the_logged_in_user(self): self.check_in(self.other, self.today, neck=9, headache=9, note='Private record') mine = self.check_in(self.user, self.today, neck=1, headache=2) response = self.client.get(reverse('planner:neck-headache-checkin-panel')) self.assertEqual(response.status_code, 200) self.assertEqual(response.context['check_in_form'].instance, mine) self.assertNotContains(response, 'Private record') response = self.client.post(reverse('planner:neck-headache-checkin-save'), { 'check_in_date': self.today.isoformat(), "morning_neck_pain_severity": 2, "morning_headache_severity": 2, "morning_note": "My update", "afternoon_neck_pain_severity": 2, "afternoon_headache_severity": 2, "evening_neck_pain_severity": 2, "evening_headache_severity": 2, }) self.assertEqual(response.status_code, 302) mine.refresh_from_db() self.assertEqual((mine.morning_neck_pain_severity, mine.morning_headache_severity), (2, 2)) self.assertEqual(NeckHeadacheCheckIn.objects.filter(user=self.other).count(), 1) def test_saving_an_existing_date_edits_instead_of_creating_a_second_entry(self): check_in = self.check_in(self.user, self.today - timedelta(days=2), neck=7, headache=1) response = self.client.post(reverse('planner:neck-headache-checkin-save'), { 'check_in_date': check_in.check_in_date.isoformat(), "morning_neck_pain_severity": 0, "morning_headache_severity": 2, "morning_note": "Improved after treatment", "afternoon_neck_pain_severity": 1, "afternoon_headache_severity": 1, "evening_neck_pain_severity": 0, "evening_headache_severity": 0, 'had_physiotherapy': 'on', }, HTTP_HX_REQUEST='true') self.assertEqual(response.status_code, 200) self.assertEqual(NeckHeadacheCheckIn.objects.filter(user=self.user).count(), 1) check_in.refresh_from_db() self.assertEqual(check_in.morning_neck_pain_severity, 0) self.assertTrue(check_in.had_physiotherapy) self.assertContains(response, 'Improved after treatment') def test_unrecorded_time_period_breaks_a_confirmed_streak_and_notes_are_textareas(self): yesterday = self.check_in(self.user, self.today - timedelta(days=1), neck=1, headache=1) partial_today = NeckHeadacheCheckIn.objects.create( user=self.user, check_in_date=self.today, morning_neck_pain_severity=1, morning_headache_severity=1, morning_note="Only checked in this morning.", ) streaks = calculate_check_in_streaks([yesterday, partial_today], self.today) self.assertEqual(streaks.current, 0) self.assertEqual(streaks.longest, 1) response = self.client.get(reverse("planner:neck-headache-checkin-panel")) self.assertContains(response, "name=\"morning_note\"") self.assertContains(response, "textarea") self.assertContains(response, "checkin-day__period--unrecorded") def test_missing_days_break_confirmed_streaks(self): entries = [ self.check_in(self.user, self.today - timedelta(days=6), neck=1, headache=2), self.check_in(self.user, self.today - timedelta(days=5), neck=0, headache=0), self.check_in(self.user, self.today - timedelta(days=4), neck=2, headache=1), # The missing day at today - 3 must break the earlier run. self.check_in(self.user, self.today - timedelta(days=2), neck=8, headache=0), self.check_in(self.user, self.today - timedelta(days=1), neck=1, headache=2), self.check_in(self.user, self.today, neck=2, headache=2), ] streaks = calculate_check_in_streaks(entries, self.today) self.assertEqual(streaks.current, 2) self.assertEqual(streaks.longest, 3) class SleepCheckInTests(TestCase): def setUp(self): self.user = get_user_model().objects.create_user(username="sleep-owner", password="password") self.other = get_user_model().objects.create_user(username="other-sleep-owner", password="password") self.client.force_login(self.user) self.today = timezone.localdate() def sleep_check_in(self, user, day, rested=0, **kwargs): return SleepCheckIn.objects.create( user=user, wake_up_date=day, rested_score=rested, **kwargs ) def test_sleep_entries_are_private_and_display_with_the_selected_pain_date(self): self.sleep_check_in(self.other, self.today, rested=1, note="Private sleep") mine = self.sleep_check_in(self.user, self.today, rested=8, watch_sleep_score=87) NeckHeadacheCheckIn.objects.create( user=self.user, check_in_date=self.today, morning_neck_pain_severity=2, morning_headache_severity=1 ) response = self.client.get(reverse("planner:neck-headache-checkin-panel")) self.assertEqual(response.context["sleep_check_in_form"].instance, mine) self.assertContains(response, "sleep rested 8 of 10") self.assertContains(response, "Sleep check-in") self.assertNotContains(response, "Private sleep") def test_sleep_tab_is_accessible_and_keeps_calendar_navigation_in_the_same_tab(self): response = self.client.get(reverse("planner:neck-headache-checkin-panel"), {"tab": "sleep"}) self.assertContains(response, "role=\"tablist\"") self.assertContains(response, "aria-selected=\"true\"") self.assertContains(response, "name=\"rested_score\"") self.assertNotContains(response, "name=\"morning_neck_pain_severity\"") self.assertContains(response, "&tab=sleep") def test_past_sleep_entry_is_edited_without_touching_another_users_entry(self): day = self.today - timedelta(days=3) mine = self.sleep_check_in(self.user, day, rested=3) self.sleep_check_in(self.other, day, rested=9, note="Private sleep") response = self.client.post(reverse("planner:sleep-checkin-save"), { "wake_up_date": day.isoformat(), "rested_score": "7", "watch_sleep_score": "91", "note": "Much better", }, HTTP_HX_REQUEST="true") self.assertEqual(response.status_code, 200) self.assertEqual(SleepCheckIn.objects.filter(user=self.user).count(), 1) mine.refresh_from_db() self.assertEqual((mine.rested_score, mine.watch_sleep_score, mine.note), (7, 91, "Much better")) self.assertEqual(SleepCheckIn.objects.get(user=self.other).rested_score, 9) def test_saving_on_a_foreign_users_date_creates_only_my_sleep_entry(self): self.sleep_check_in(self.other, self.today, rested=9) response = self.client.post(reverse("planner:sleep-checkin-save"), { "wake_up_date": self.today.isoformat(), "rested_score": "6", "watch_sleep_score": "", "note": "My entry", }) self.assertEqual(response.status_code, 302) mine = SleepCheckIn.objects.get(user=self.user, wake_up_date=self.today) self.assertEqual(mine.rested_score, 6) self.assertIsNone(mine.watch_sleep_score) self.assertEqual(SleepCheckIn.objects.get(user=self.other).rested_score, 9) class PhysiotherapyCounterTests(TestCase): def test_counter_is_user_scoped_and_resets_each_calendar_year(self): user = get_user_model().objects.create_user(username='physio-counter', password='password') other = get_user_model().objects.create_user(username='other-physio-counter', password='password') today = timezone.localdate() NeckHeadacheCheckIn.objects.create( user=user, check_in_date=today, had_physiotherapy=True, ) NeckHeadacheCheckIn.objects.create( user=user, check_in_date=today - timedelta(days=1), had_physiotherapy=True, ) NeckHeadacheCheckIn.objects.create( user=user, check_in_date=date(today.year - 1, 12, 31), had_physiotherapy=True, ) NeckHeadacheCheckIn.objects.create( user=other, check_in_date=today, had_physiotherapy=True, ) self.client.force_login(user) response = self.client.get(reverse('planner:neck-headache-checkin-panel')) self.assertEqual(response.context['physio_sessions_this_year'], 2) self.assertEqual(response.context['annual_physio_session_allowance'], 12) self.assertContains(response, 'Physio sessions this year') self.assertContains(response, '2/12') class TaskCompletionViewTests(TestCase): def setUp(self): self.owner = get_user_model().objects.create_user(username='task-completion-owner', password='password') self.other = get_user_model().objects.create_user(username='other-task-completion-owner', password='password') self.client.force_login(self.owner) self.today = timezone.localdate() self.parent = Task.objects.create( owner=self.owner, title='Wash clothes', scheduled_for=self.today, ) self.child = Task.objects.create( owner=self.owner, title='Fold clothes', scheduled_for=self.today, parent_task=self.parent, ) def test_completing_parent_unlocks_child_and_is_owner_scoped(self): before = self.client.get(reverse('planner:daily-planner'), { 'selected_date': self.today.isoformat(), 'energy_level': 3, }) self.assertContains(before, 'Wash clothes') self.assertNotContains(before, 'Fold clothes') self.assertContains(before, 'Mark complete') response = self.client.post( reverse('planner:task-toggle-completed', args=[self.parent.pk]), HTTP_HX_REQUEST='true', ) self.assertEqual(response.status_code, 200) self.parent.refresh_from_db() self.assertTrue(self.parent.is_completed) self.assertContains(response, 'subtask unlocked') after = self.client.get(reverse('planner:daily-planner'), { 'selected_date': self.today.isoformat(), 'energy_level': 3, }) self.assertContains(after, 'Fold clothes') self.assertNotContains(after, 'Wash clothes') def test_daily_planner_completion_redirects_back_to_the_same_plan(self): response = self.client.post( reverse('planner:task-toggle-completed', args=[self.parent.pk]), { 'return_to_daily_planner': '1', 'selected_date': self.today.isoformat(), 'energy_level': '3', }, HTTP_HX_REQUEST='true', ) self.assertEqual(response.status_code, 204) self.assertEqual( response['HX-Redirect'], f"{reverse('planner:daily-planner')}?selected_date={self.today.isoformat()}&energy_level=3", ) self.parent.refresh_from_db() self.assertTrue(self.parent.is_completed) foreign = Task.objects.create(owner=self.other, title='Private parent', scheduled_for=self.today) self.assertEqual( self.client.post(reverse('planner:task-toggle-completed', args=[foreign.pk])).status_code, 404, )