Files
Django_TasksApp/main/stress/tests.py
T
2026-10-19 16:51:53 +02:00

134 lines
8.4 KiB
Python

import json
from datetime import datetime, timezone as datetime_timezone
from unittest.mock import patch
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from food.api import create_token
from planner.models import UserSettings
from .services import save_daily_entry
from .models import StressEntry
class StressJournalTests(TestCase):
def setUp(self):
users = get_user_model()
self.user = users.objects.create_user(username='stress-one', password='test-password')
self.other = users.objects.create_user(username='stress-two', password='test-password')
def test_multiple_checkins_web_edit_and_owner_isolation(self):
self.client.force_login(self.user)
url = reverse('stress:journal')
for score, timing in ((7, 'before_sleep'), (3, 'after_waking')):
response = self.client.post(url, {
'recorded_at': '2026-10-18T08:00', 'timing': timing, 'score': score,
'note': 'Some stress', 'tags_text': 'work, sensory overload',
'symptoms': ['tension'],
})
self.assertEqual(response.status_code, 302)
self.assertEqual(StressEntry.objects.filter(user=self.user).count(), 2)
entry = StressEntry.objects.filter(user=self.user, timing='before_sleep').get()
self.assertEqual(entry.tags, ['work', 'sensory overload'])
self.assertEqual(entry.symptoms, ['tension'])
self.assertContains(self.client.get(url), 'Before sleep: 7/10')
self.assertContains(self.client.get(url), 'After waking: 3/10')
self.assertEqual(self.client.get(reverse('stress:edit', args=[entry.pk])).status_code, 200)
self.client.force_login(self.other)
self.assertEqual(self.client.get(reverse('stress:edit', args=[entry.pk])).status_code, 404)
self.assertEqual(self.client.post(reverse('stress:delete', args=[entry.pk])).status_code, 404)
self.assertNotContains(self.client.get(url), 'Some stress')
def test_api_scopes_idempotency_search_update_and_delete(self):
_, secret = create_token(self.user, 'Stress test', ['journal:read', 'journal:write'])
headers = {'HTTP_AUTHORIZATION': f'Bearer {secret}'}
url = '/api/v1/stress/'
payload = {'score': 8, 'timing': 'before_sleep', 'note': 'Work deadline',
'recorded_at': '2026-10-17T22:30:00', 'tags': ['work'], 'symptoms': ['tension']}
options = {**headers, 'HTTP_IDEMPOTENCY_KEY': 'stress-test-1', 'content_type': 'application/json'}
created = self.client.post(url, data=json.dumps(payload), **options)
self.assertEqual(created.status_code, 201)
entry_id = created.json()['id']
self.assertEqual(self.client.post(url, data=json.dumps(payload), **options).json()['id'], entry_id)
self.assertEqual(StressEntry.objects.count(), 1)
self.assertEqual(self.client.post(url, data=json.dumps({**payload, 'score': 9}), **options).status_code, 409)
self.assertEqual(self.client.get(url, {'date': '2026-10-17', 'timing': 'before_sleep'}, **headers).json()['total'], 1)
detail = f'{url}{entry_id}/'
changed = self.client.patch(detail, data=json.dumps({'note': 'Deadline moved'}),
content_type='application/json', **headers)
self.assertEqual(changed.status_code, 200)
self.assertEqual(changed.json()['score'], 8)
self.assertEqual(changed.json()['note'], 'Deadline moved')
_, other_secret = create_token(self.other, 'Stress test', ['journal:read', 'journal:write'])
other_headers = {'HTTP_AUTHORIZATION': f'Bearer {other_secret}'}
self.assertEqual(self.client.get(detail, **other_headers).status_code, 404)
self.assertEqual(self.client.delete(detail, **other_headers).status_code, 404)
self.assertEqual(self.client.get(url, **other_headers).json()['total'], 0)
self.assertEqual(self.client.delete(detail, **headers).status_code, 200)
self.assertEqual(StressEntry.objects.count(), 0)
def test_api_rejects_invalid_score_and_read_only_token(self):
_, secret = create_token(self.user, 'Read only', ['journal:read'])
headers = {'HTTP_AUTHORIZATION': f'Bearer {secret}'}
self.assertEqual(self.client.post('/api/v1/stress/', data=json.dumps({'score': 7}),
content_type='application/json', **headers).status_code, 403)
_, write_secret = create_token(self.user, 'Write', ['journal:write'])
write_headers = {'HTTP_AUTHORIZATION': f'Bearer {write_secret}'}
self.assertEqual(self.client.post('/api/v1/stress/', data=json.dumps({'score': 11}),
content_type='application/json', **write_headers).status_code, 400)
self.assertEqual(self.client.get('/api/v1/stress/', **write_headers).status_code, 403)
def test_daily_widget_revises_one_row_without_duplicate_scores(self):
UserSettings.objects.create(user=self.user, time_zone='Europe/Amsterdam')
first = datetime(2026, 10, 18, 19, 30, tzinfo=datetime_timezone.utc)
second = datetime(2026, 10, 18, 20, 10, tzinfo=datetime_timezone.utc)
next_day = datetime(2026, 10, 18, 22, 30, tzinfo=datetime_timezone.utc)
with patch('stress.services.timezone.now', return_value=first):
entry = save_daily_entry(self.user, score=4, timing='before_sleep', note='Busy day', stressor='work')
with patch('stress.services.timezone.now', return_value=second):
updated = save_daily_entry(self.user, score=6, timing='before_sleep', note='A bit calmer', stressor='work')
save_daily_entry(self.user, score=6, timing='before_sleep', note='Same score', stressor='work')
updated.refresh_from_db()
self.assertEqual(updated.pk, entry.pk)
self.assertEqual(updated.daily_date.isoformat(), '2026-10-18')
self.assertEqual([revision['score'] for revision in updated.revisions], [4, 6])
self.assertEqual(updated.revisions[0]['time'], first.isoformat())
self.assertEqual(updated.revisions[1]['time'], second.isoformat())
self.assertEqual(updated.note, 'Same score')
with patch('stress.services.timezone.now', return_value=next_day):
tomorrow = save_daily_entry(self.user, score=3)
self.assertNotEqual(tomorrow.pk, entry.pk)
self.assertEqual(tomorrow.daily_date.isoformat(), '2026-10-19')
self.assertEqual(StressEntry.objects.filter(user=self.user, daily_date__isnull=False).count(), 2)
def test_daily_widget_post_and_health_access(self):
self.client.force_login(self.user)
home = self.client.get(reverse('planner:task-list'))
self.assertContains(home, 'desktop-stress-widget')
self.assertContains(home, 'mobile-stress-widget')
self.assertContains(self.client.get(reverse('planner:health')), 'health-stress-widget')
response = self.client.post(reverse('stress:daily-save'), {
'score': '0', 'timing': 'after_waking', 'note': 'Quiet', 'stressor': 'sleep', 'return_to': 'home'})
self.assertEqual(response.status_code, 302)
entry = StressEntry.objects.get(user=self.user, daily_date__isnull=False)
self.assertEqual(entry.score, 0)
self.assertEqual(entry.revisions[0]['score'], 0)
self.client.post(reverse('stress:daily-save'), {
'score': '2', 'timing': 'after_waking', 'note': 'Later', 'return_to': 'health'})
entry.refresh_from_db()
self.assertEqual(entry.score, 2)
self.assertEqual(len(entry.revisions), 2)
self.assertEqual(StressEntry.objects.filter(user=self.user).count(), 1)
self.assertEqual(self.client.post(reverse('stress:daily-save'), {'score': '11'}).status_code, 302)
self.assertEqual(StressEntry.objects.filter(user=self.user).count(), 1)
def test_api_change_to_daily_score_keeps_revision_history(self):
entry = save_daily_entry(self.user, score=4)
_, secret = create_token(self.user, 'Journal write', ['journal:write'])
response = self.client.patch(f'/api/v1/stress/{entry.pk}/', data=json.dumps({'score': 7}),
content_type='application/json', HTTP_AUTHORIZATION=f'Bearer {secret}')
self.assertEqual(response.status_code, 200)
entry.refresh_from_db()
self.assertEqual(entry.score, 7)
self.assertEqual([item['score'] for item in entry.revisions], [4, 7])