Files
Django_TasksApp/main/planner/test_demo_policy.py
T
2026-10-22 10:32:41 +02:00

127 lines
7.4 KiB
Python

from django.contrib.auth import get_user_model
from django.core.files.base import ContentFile
from django.core.management import call_command
from django.core.cache import cache
from django.test import TestCase, override_settings
from django.urls import reverse
from django.utils import timezone
from datetime import timedelta
from oauth2_provider.models import Application, get_grant_model
from dreams.models import DreamEntry
from food.api import create_token
from food.models import PersonalAccessToken
from food.models import FoodLogAttachment, FoodLogEntry
from planner.models import UserSettings
from recipes.models import Recipe
from stress.models import StressEntry
from tempfile import TemporaryDirectory
class DemoPolicyTests(TestCase):
def setUp(self):
self.demo = get_user_model().objects.create_user('synthetic-demo', password='test')
UserSettings.objects.create(user=self.demo, is_demo=True)
self.normal = get_user_model().objects.create_user('synthetic-normal', password='test')
self.client.force_login(self.demo)
def test_demo_cannot_create_tokens_or_authorize(self):
with self.assertRaises(ValueError):
create_token(self.demo, 'blocked', ['food:read'])
self.assertEqual(self.client.get(reverse('food:tokens')).status_code, 403)
self.assertEqual(self.client.get('/o/authorize/').status_code, 403)
self.assertFalse(PersonalAccessToken.objects.filter(user=self.demo).exists())
self.assertEqual(self.client.get('/settings/notifications/ntfy/test/').status_code, 403)
def test_demo_cannot_trigger_external_requests_or_upload(self):
self.assertEqual(self.client.post('/food/search/openfoodfacts/', {'q': 'oats'}).status_code, 403)
self.assertEqual(self.client.post('/recipes/new/', content_type='multipart/form-data').status_code, 403)
self.assertEqual(self.client.post('/recipes/new/', {'title': 'Injected'}).status_code, 403)
self.assertEqual(self.client.post('/settings/', {'section': 'ntfy', 'ntfy_url': 'https://example.com'}).status_code, 403)
def test_normal_user_keeps_token_access(self):
self.client.force_login(self.normal)
self.assertEqual(self.client.get(reverse('food:tokens')).status_code, 200)
token, _ = create_token(self.normal, 'allowed', ['food:read'])
self.assertEqual(token.user_id, self.normal.pk)
def test_legacy_demo_oauth_code_cannot_be_exchanged_anonymously(self):
application = Application.objects.create(user=self.demo, name='Legacy demo client',
client_type=Application.CLIENT_PUBLIC,
authorization_grant_type=Application.GRANT_AUTHORIZATION_CODE,
redirect_uris='https://example.com/callback')
get_grant_model().objects.create(user=self.demo, application=application,
code='legacy-demo-code', expires=timezone.now() + timedelta(minutes=5),
redirect_uri='https://example.com/callback', scope='food:read')
self.client.logout()
response = self.client.post('/o/token/', {'grant_type': 'authorization_code',
'code': 'legacy-demo-code'})
self.assertEqual(response.status_code, 403)
self.assertEqual(response.json()['error'], 'access_denied')
@override_settings(DEMO_MUTATIONS_PER_MINUTE=2)
def test_demo_mutation_rate_and_body_size_limits(self):
cache.clear()
url = reverse('planner:hydration-add')
self.assertEqual(self.client.post(url).status_code, 200)
self.assertEqual(self.client.post(url).status_code, 200)
self.assertEqual(self.client.post(url).status_code, 429)
cache.clear()
response = self.client.post(url, data='x' * (1024 * 1024 + 1), content_type='text/plain')
self.assertEqual(response.status_code, 413)
class DemoResetTests(TestCase):
def test_reset_clears_new_journals_and_tokens_without_touching_other_user(self):
call_command('seed_demo', username='synthetic-seed', password='test', verbosity=0)
demo = get_user_model().objects.get(username='synthetic-seed')
other = get_user_model().objects.create_user('synthetic-other', password='test')
temporary_stress = StressEntry.objects.create(user=demo, score=3)
StressEntry.objects.create(user=other, score=3)
temporary_dream = DreamEntry.objects.create(user=demo, wake_up_date='2026-10-19',
title='Temporary dream', narrative='Demo data')
token = PersonalAccessToken.objects.create(user=demo, name='legacy', prefix='legacy123',
token_hash='0' * 64, scopes=['food:read'])
call_command('seed_demo', username='synthetic-seed', verbosity=0)
self.assertFalse(StressEntry.objects.filter(pk=temporary_stress.pk).exists())
self.assertTrue(StressEntry.objects.filter(user=other).exists())
self.assertFalse(DreamEntry.objects.filter(pk=temporary_dream.pk).exists())
self.assertEqual(StressEntry.objects.filter(user=demo).count(), 1)
self.assertEqual(DreamEntry.objects.filter(user=demo).count(), 1)
self.assertFalse(PersonalAccessToken.objects.filter(pk=token.pk).exists())
self.assertTrue(UserSettings.objects.get(user=demo).is_demo)
demo.refresh_from_db()
self.assertTrue(demo.check_password('test'))
def test_reset_refuses_unmarked_account(self):
from django.core.management.base import CommandError
user = get_user_model().objects.create_user('synthetic-real', password='test')
UserSettings.objects.create(user=user)
with self.assertRaises(CommandError):
call_command('seed_demo', username='synthetic-real', password='test', verbosity=0)
def test_reset_removes_owned_files_and_sessions(self):
with TemporaryDirectory() as media_root, override_settings(MEDIA_ROOT=media_root):
with self.captureOnCommitCallbacks(execute=True):
call_command('seed_demo', username='synthetic-files', password='test', verbosity=0)
demo = get_user_model().objects.get(username='synthetic-files')
recipe = Recipe.objects.create(owner=demo, title='Temporary recipe')
curated = Recipe.objects.create(owner=demo, title='Curated recipe',
status=Recipe.Status.PUBLISHED)
recipe.photo.save('recipe.png', ContentFile(b'recipe image'), save=True)
entry = FoodLogEntry.objects.filter(user=demo).first()
attachment = FoodLogAttachment(log_entry=entry, original_filename='food.png',
content_type='image/png', file_size=10)
attachment.image.save('food.png', ContentFile(b'food image'), save=True)
recipe_path, attachment_path = recipe.photo.path, attachment.image.path
self.client.force_login(demo)
with self.captureOnCommitCallbacks(execute=True):
call_command('seed_demo', username='synthetic-files', password='test', verbosity=0)
from pathlib import Path
self.assertFalse(Path(recipe_path).exists())
self.assertFalse(Path(attachment_path).exists())
self.assertTrue(Recipe.objects.filter(pk=curated.pk).exists())
self.assertFalse(Recipe.objects.filter(pk=recipe.pk).exists())
self.assertRedirects(self.client.get(reverse('planner:user-settings')),
'/login/?next=/settings/', fetch_redirect_response=False)