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 .models import BowelHealthCheckIn, ToothBrushing, UserSettings, WaterIntakeEntry from .timezones import localdate_for_user from .services.hydration import hydration_context 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_refreshes_filtered_list(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, 'No tasks here') self.assertNotContains(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): from food.models import FoodFavourite, FoodLogEntry, FoodPortion, FoodProduct, MealType, Unit 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() ) private_food = FoodProduct.objects.create(owner=other, product_name='Private snack') private_food_entry = FoodLogEntry.objects.create( user=other, date=timezone.localdate(), meal=MealType.SNACKS, product=private_food, product_name_snapshot='Private snack', amount=100, unit=Unit.GRAM, ) 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) self.assertEqual(FoodProduct.objects.filter(owner=demo).count(), 6) self.assertEqual(FoodLogEntry.objects.filter(user=demo).count(), 10) self.assertEqual(FoodFavourite.objects.filter(user=demo).count(), 2) self.assertEqual(FoodPortion.objects.filter(user=demo).count(), 2) self.assertEqual(WaterIntakeEntry.objects.filter(user=demo).count(), 4) self.assertEqual(ToothBrushing.objects.filter(user=demo).count(), 2) self.assertEqual(BowelHealthCheckIn.objects.filter(user=demo).count(), 3) profile = UserSettings.objects.get(user=demo) self.assertEqual(profile.time_zone, "Europe/Amsterdam") self.assertFalse(profile.onboarding_enabled) self.assertEqual(profile.daily_calorie_goal, 2000) self.assertEqual(profile.carbohydrate_goal_g, 250) self.assertEqual(profile.protein_goal_g, 100) self.assertEqual(profile.fat_goal_g, 70) self.assertFalse(profile.ntfy_enabled) today = localdate_for_user(demo) self.assertEqual(FoodLogEntry.objects.filter(user=demo, date=today).count(), 6) self.assertEqual(set(FoodLogEntry.objects.filter(user=demo, date=today).values_list('meal', flat=True)), set(MealType.values)) bowl = FoodPortion.objects.get(user=demo, label='My bowl') self.assertTrue(bowl.is_default) self.assertEqual(FoodLogEntry.objects.get(user=demo, date=today, portion_label_snapshot='My bowl').calories_kcal, 182.5) 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()) FoodProduct.objects.create(owner=demo, product_name='Temporary demo food') banana = FoodProduct.objects.get(owner=demo, product_name='Banana') FoodFavourite.objects.create(user=demo, product=banana) FoodPortion.objects.create(user=demo, product=banana, label='Temporary portion', amount=100, unit=Unit.GRAM) FoodLogEntry.objects.filter(user=demo, portion_label_snapshot='My bowl').update(product_name_snapshot='Edited demo food') profile.ntfy_url = 'https://ntfy.example.com/old-demo-topic' profile.ntfy_enabled = True profile.save() 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.assertEqual(FoodProduct.objects.filter(owner=demo).count(), 6) self.assertEqual(FoodLogEntry.objects.filter(user=demo).count(), 10) self.assertFalse(FoodLogEntry.objects.filter(user=demo, product_name_snapshot='Edited demo food').exists()) self.assertEqual(FoodFavourite.objects.filter(user=demo).count(), 2) self.assertEqual(FoodPortion.objects.filter(user=demo).count(), 2) profile.refresh_from_db() self.assertFalse(profile.ntfy_enabled) self.assertEqual(profile.ntfy_url, '') self.assertTrue(Task.objects.filter(pk=private_task.pk, owner=other).exists()) self.assertTrue(FoodProduct.objects.filter(pk=private_food.pk, owner=other).exists()) self.assertTrue(FoodLogEntry.objects.filter(pk=private_food_entry.pk, user=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.assertNotContains(response, 'Wash clothes') past = self.client.get(reverse('planner:task-list'), {'status': 'past'}) self.assertContains(past, '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, ) class HydrationWidgetTests(TestCase): def setUp(self): self.user = get_user_model().objects.create_user(username='hydration-user', password='test-password') self.client.force_login(self.user) UserSettings.objects.update_or_create(user=self.user, defaults={'daily_water_goal_ml': 500}) def test_entries_total_and_over_goal_visual_cap(self): self.client.post(reverse('planner:hydration-add'), {'amount_ml': 250}) self.client.post(reverse('planner:hydration-add'), {'amount_ml': 500}) self.assertEqual(WaterIntakeEntry.objects.filter(user=self.user).count(), 2) context = hydration_context(self.user) self.assertEqual(context['hydration_total'], 750) self.assertEqual(context['hydration_percent'], 150) self.assertEqual(context['hydration_visual'], 100) self.assertEqual(next(day for day in context['hydration_days'] if day['today'])['state'], 'goal') def test_health_page_reuses_widgets_and_live_hydration(self): response = self.client.get(reverse('planner:health')) self.assertContains(response, 'Health routines') self.assertContains(response, 'id="fasting-widget"') self.assertContains(response, 'id="hydration-widget"') self.client.post(reverse('planner:hydration-add'), {'amount_ml': 250}) self.assertContains(self.client.get(reverse('planner:health')), '250 / 500 ml', html=True) def test_undo_only_current_user_current_day(self): other = get_user_model().objects.create_user(username='other-hydration-user') WaterIntakeEntry.objects.create(user=other, amount_ml=500) yesterday = timezone.now() - timedelta(days=1) WaterIntakeEntry.objects.create(user=self.user, amount_ml=250, recorded_at=yesterday) self.client.post(reverse('planner:hydration-add'), {'amount_ml': 500}) self.client.post(reverse('planner:hydration-undo')) self.assertEqual(hydration_context(self.user)['hydration_total'], 0) self.assertEqual(WaterIntakeEntry.objects.filter(user=self.user).count(), 1) self.assertEqual(WaterIntakeEntry.objects.filter(user=other).count(), 1) def test_week_rolls_forward_and_invalid_amount_is_rejected(self): monday = timezone.now().astimezone(ZoneInfo('Europe/Amsterdam')) monday = monday - timedelta(days=monday.weekday()) prior_week = monday - timedelta(days=7) WaterIntakeEntry.objects.create(user=self.user, amount_ml=500, recorded_at=prior_week) self.assertTrue(all(day['state'] == 'none' for day in hydration_context(self.user)['hydration_days'])) response = self.client.post(reverse('planner:hydration-add'), {'amount_ml': 3001}) self.assertContains(response, 'Enter a whole amount') self.assertEqual(WaterIntakeEntry.objects.filter(user=self.user).count(), 1)