Files
2026-10-21 15:25:33 +02:00

184 lines
11 KiB
Python

import hashlib
import json
from django.contrib.auth import get_user_model
from django.test import TestCase
from django.urls import reverse
from django.core.management import call_command
from django.test import override_settings
from django.utils import timezone
from datetime import timedelta
from unittest.mock import patch
from .models import CaptureToken, SavedItem
from .services import relevant_items, save_item
from .notifications import rediscover_once
from .metadata import MetadataError, fetch_metadata, public_address, youtube_video_id
class KnowledgeTests(TestCase):
def setUp(self):
self.alice = get_user_model().objects.create_user('alice', password='test-password')
self.bob = get_user_model().objects.create_user('bob', password='test-password')
def test_capture_is_idempotent_and_owner_scoped(self):
token = 'capture-secret'
CaptureToken.objects.create(owner=self.alice, name='Shortcut', token_hash=hashlib.sha256(token.encode()).hexdigest())
url = reverse('knowledge_api_add')
headers = {'HTTP_AUTHORIZATION': f'Bearer {token}', 'content_type': 'application/json'}
first = self.client.post(url, data=json.dumps({'url': 'https://example.org/esp32#top', 'title': 'ESP32'}), **headers)
second = self.client.post(url, data=json.dumps({'url': 'https://EXAMPLE.org/esp32'}), **headers)
self.assertEqual(first.status_code, 201)
self.assertEqual(second.status_code, 200)
self.assertTrue(second.json()['duplicate'])
self.assertEqual(SavedItem.objects.filter(owner=self.alice).count(), 1)
self.assertEqual(SavedItem.objects.filter(owner=self.bob).count(), 0)
self.assertEqual(self.client.post(url, data='{}', content_type='application/json').status_code, 401)
def test_private_url_and_cross_user_visibility(self):
token = 'capture-secret'
CaptureToken.objects.create(owner=self.alice, name='Shortcut', token_hash=hashlib.sha256(token.encode()).hexdigest())
response = self.client.post(reverse('knowledge_api_add'), data=json.dumps({'url': 'http://127.0.0.1/admin'}),
content_type='application/json', HTTP_AUTHORIZATION=f'Bearer {token}')
self.assertEqual(response.status_code, 400)
item, _ = save_item(self.alice, 'https://example.org/sensor', title='ESP32 sensor microphone')
self.assertEqual(relevant_items(self.bob, 'ESP32 sensor microphone'), [])
self.assertEqual(relevant_items(self.alice, 'ESP32 sensor microphone')[0][1], item)
self.client.force_login(self.bob)
self.assertNotContains(self.client.get(reverse('knowledge:index')), 'ESP32 sensor microphone')
self.assertEqual(self.client.post(reverse('knowledge:archive', args=[item.pk])).status_code, 404)
def test_token_revocation(self):
self.client.force_login(self.alice)
self.client.post(reverse('knowledge:tokens'), {'name': 'Shortcut'})
token = CaptureToken.objects.get(owner=self.alice)
self.client.post(reverse('knowledge:tokens'), {'action': 'revoke', 'token_id': token.pk})
token.refresh_from_db()
self.assertIsNotNone(token.revoked_at)
@override_settings(KNOWLEDGE_NTFY_ENABLED=True, KNOWLEDGE_NTFY_URL='https://ntfy.example.org/topic',
KNOWLEDGE_NTFY_WEEKLY_LIMIT=1, KNOWLEDGE_NTFY_QUIET_START=23, KNOWLEDGE_NTFY_QUIET_END=6)
@patch('knowledge.notifications.send_ntfy_notification')
def test_ntfy_limit_and_cooldown(self, sender):
item, _ = save_item(self.alice, 'https://example.org/esp32', title='ESP32 sensors')
SavedItem.objects.filter(pk=item.pk).update(created_at=timezone.now() - timedelta(days=5))
with override_settings(KNOWLEDGE_NTFY_USER_ID=str(self.alice.pk)):
now = timezone.now().replace(hour=12)
self.assertEqual(rediscover_once(now), 'delivered')
self.assertEqual(rediscover_once(now), 'weekly_limit')
sender.assert_called_once()
@patch('knowledge.metadata.socket.getaddrinfo')
def test_metadata_rejects_private_dns_answer(self, resolver):
resolver.return_value = [(None, None, None, None, ('192.168.1.1', 443))]
with self.assertRaises(MetadataError):
public_address('example.org', 443)
@patch('knowledge.metadata.PinnedHTTPConnection')
@patch('knowledge.metadata.public_address', return_value='93.184.215.14')
def test_metadata_reads_only_bounded_html(self, resolver, connection_type):
response = connection_type.return_value.getresponse.return_value
response.status = 200
response.getheader.side_effect = lambda name: {'Content-Type': 'text/html; charset=utf-8', 'Content-Length': '90'}.get(name)
response.read.side_effect = [b'<title>Useful ESP32 page</title><meta name="description" content="A sensor guide">', b'']
result = fetch_metadata('https://example.org/esp32')
self.assertEqual(result['extracted_title'], 'Useful ESP32 page')
self.assertEqual(result['description'], 'A sensor guide')
connection_type.assert_called_once_with('example.org', 443, '93.184.215.14', True)
@patch('knowledge.metadata._fetch_bytes')
def test_open_graph_precedence_and_fallback(self, fetch):
html = b'''<title>HTML title</title><meta name="description" content="HTML description">
<meta name="twitter:title" content="Twitter title"><meta name="twitter:image" content="https://example.org/tw.jpg">
<meta property="og:title" content="OG title"><meta property="og:description" content="OG description">
<meta property="og:image" content="https://example.org/og.jpg"><meta property="og:image:alt" content="A flower">
<meta property="og:site_name" content="Example Journal"><link rel="icon" href="/favicon.png">'''
fetch.return_value = ('https://example.org/article', html)
result = fetch_metadata('https://example.org/article')
self.assertEqual(result['extracted_title'], 'OG title')
self.assertEqual(result['description'], 'OG description')
self.assertEqual(result['thumbnail_url'], 'https://example.org/og.jpg')
self.assertEqual(result['image_alt'], 'A flower')
self.assertEqual(result['site_name'], 'Example Journal')
self.assertEqual(result['favicon_url'], 'https://example.org/favicon.png')
fetch.return_value = ('https://example.org/article', b'<title>HTML only</title>')
self.assertEqual(fetch_metadata('https://example.org/article')['extracted_title'], 'HTML only')
fetch.return_value = ('https://example.org/article', b'<html><head></head><body>Nothing to extract</body></html>')
self.assertEqual(fetch_metadata('https://example.org/article')['extracted_title'], '')
@patch('knowledge.metadata._fetch_bytes')
def test_youtube_oembed_uses_allowlisted_embed(self, fetch):
fetch.return_value = ('https://www.youtube.com/oembed', json.dumps({
'title': 'Circuit demo', 'author_name': 'Maker channel',
'thumbnail_url': 'https://i.ytimg.com/vi/dQw4w9WgXcQ/hqdefault.jpg'}).encode())
result = fetch_metadata('https://youtu.be/dQw4w9WgXcQ')
self.assertEqual(result['site_name'], 'Maker channel')
self.assertEqual(result['embed_url'], 'https://www.youtube-nocookie.com/embed/dQw4w9WgXcQ')
self.assertEqual(youtube_video_id('https://youtube.com.evil.test/watch?v=dQw4w9WgXcQ'), '')
@patch('knowledge.metadata.PinnedHTTPConnection')
@patch('knowledge.metadata.public_address', return_value='93.184.215.14')
def test_redirect_to_private_address_is_blocked(self, resolver, connection_type):
response = connection_type.return_value.getresponse.return_value
response.status = 302
response.getheader.return_value = 'http://127.0.0.1/admin'
with self.assertRaises(MetadataError):
fetch_metadata('https://example.org/article')
@patch('knowledge.metadata.PinnedHTTPConnection')
@patch('knowledge.metadata.public_address', return_value='93.184.215.14')
def test_timeout_is_a_safe_failure(self, resolver, connection_type):
import socket
connection_type.return_value.request.side_effect = socket.timeout()
with self.assertRaises(MetadataError):
fetch_metadata('https://example.org/article')
@patch('knowledge.management.commands.fetch_knowledge_metadata.fetch_metadata')
def test_metadata_refresh_preserves_user_edits_and_cache(self, fetch):
item, _ = save_item(self.alice, 'https://example.org/article')
self.client.force_login(self.alice)
self.client.post(reverse('knowledge:edit', args=[item.pk]), {
'title': 'My title', 'description': 'My notes on this', 'preview_mode': 'preview'})
fetch.return_value = {'extracted_title': 'Publisher title', 'description': 'Publisher description',
'thumbnail_url': 'https://example.org/image.jpg', 'image_alt': 'Image', 'site_name': 'Example',
'favicon_url': '', 'provider': 'web', 'embed_url': '', 'canonical_url': ''}
call_command('fetch_knowledge_metadata')
item.refresh_from_db()
self.assertEqual(item.title, 'My title')
self.assertEqual(item.user_description, 'My notes on this')
self.assertEqual(item.description, 'Publisher description')
self.assertEqual(item.metadata_status, SavedItem.MetadataStatus.READY)
call_command('fetch_knowledge_metadata')
self.assertEqual(fetch.call_count, 1)
self.assertContains(self.client.get(reverse('knowledge:index')), 'My title')
self.assertContains(self.client.get(reverse('knowledge:index')), 'My notes on this')
def test_preview_escapes_metadata_and_defers_youtube_embed(self):
item, _ = save_item(self.alice, 'https://youtu.be/dQw4w9WgXcQ')
item.provider = 'youtube'
item.embed_url = 'https://www.youtube-nocookie.com/embed/dQw4w9WgXcQ'
item.extracted_title = '<script>alert(1)</script>'
item.thumbnail_url = 'https://i.ytimg.com/vi/dQw4w9WgXcQ/hqdefault.jpg'
item.save()
self.client.force_login(self.alice)
response = self.client.get(reverse('knowledge:index'))
self.assertContains(response, '&lt;script&gt;alert(1)&lt;/script&gt;')
self.assertNotContains(response, '<iframe')
self.assertContains(response, 'Play video')
self.assertContains(response, 'knowledge-image-fallback')
self.client.force_login(self.bob)
self.assertEqual(self.client.get(reverse('knowledge:item_card', args=[item.pk])).status_code, 404)
@patch('knowledge.management.commands.fetch_knowledge_metadata.fetch_metadata', side_effect=MetadataError('HTTP 503.'))
def test_worker_retries_with_backoff_and_keeps_saved_link(self, fetch):
item, _ = save_item(self.alice, 'https://example.org/broken')
call_command('fetch_knowledge_metadata')
item.refresh_from_db()
self.assertEqual(item.metadata_status, SavedItem.MetadataStatus.ERROR)
self.assertEqual(item.metadata_attempts, 1)
self.assertGreater(item.metadata_retry_at, timezone.now())
call_command('fetch_knowledge_metadata')
self.assertEqual(fetch.call_count, 1)
self.client.force_login(self.alice)
self.assertContains(self.client.get(reverse('knowledge:index')), 'Preview unavailable')
self.assertContains(self.client.get(reverse('knowledge:index')), 'https://example.org/broken')