1514 lines
70 KiB
Python
1514 lines
70 KiB
Python
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_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):
|
|
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.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,
|
|
)
|