184 lines
11 KiB
Python
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, '<script>alert(1)</script>')
|
|
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')
|