134 lines
8.4 KiB
Python
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])
|