127 lines
7.4 KiB
Python
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)
|