article-backup 0.3.3__tar.gz → 0.3.4__tar.gz

{article_backup-0.3.3 → article_backup-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: article-backup
-Version: 0.3.3
+Version: 0.3.4
 Summary: Локальный бэкап статей с Sponsr.ru и Boosty.to в Markdown с Hugo-интеграцией
 Author-email: Eugene Chaykin <eugene@chayk.in>
 License: Apache-2.0

{article_backup-0.3.3 → article_backup-0.3.4}/article_backup.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: article-backup
-Version: 0.3.3
+Version: 0.3.4
 Summary: Локальный бэкап статей с Sponsr.ru и Boosty.to в Markdown с Hugo-интеграцией
 Author-email: Eugene Chaykin <eugene@chayk.in>
 License: Apache-2.0

{article_backup-0.3.3 → article_backup-0.3.4}/article_backup.egg-info/SOURCES.txt

@@ -16,7 +16,9 @@ src/downloader.py
 src/sponsr.py
 src/utils.py
 tests/test_asset_dedup.py
+tests/test_boosty_empty_link.py
 tests/test_boosty_normalize.py
 tests/test_incremental_sync.py
 tests/test_sponsr_normalize.py
-tests/test_sponsr_tags.py
+tests/test_sponsr_tags.py
+tests/test_video_embed.py

{article_backup-0.3.3 → article_backup-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "article-backup"
-version = "0.3.3"
+version = "0.3.4"
 description = "Локальный бэкап статей с Sponsr.ru и Boosty.to в Markdown с Hugo-интеграцией"
 readme = "README.md"
 license = {text = "Apache-2.0"}

{article_backup-0.3.3 → article_backup-0.3.4}/src/boosty.py

@@ -240,8 +240,8 @@ class BoostyDownloader(BaseDownloader):
             text = self._parse_text_block(block, paragraph_offset)
             if text and url:
                 return f"[{text}]({url})"
-            elif url:
-                return f"<{url}>"
+            # Пустые ссылки (без текста) пропускаем — это часто артефакты редактора
+            # Было: elif url: return f"<{url}>"
 
         elif block_type == "audio_file":
             url = block.get("url", "")
@@ -254,7 +254,7 @@ class BoostyDownloader(BaseDownloader):
 
         elif block_type == "ok_video":
             video_id = block.get("id", "")
-            return f"\n📹 Видео: https://ok.ru/video/{video_id}\n"
+            return f"\n[\U0001f4f9 Видео](https://ok.ru/videoembed/{video_id})\n"
 
         return ""
 

{article_backup-0.3.3 → article_backup-0.3.4}/src/sponsr.py

@@ -14,14 +14,14 @@ from .config import Config, Source, load_cookie
 from .database import Database
 from .downloader import BaseDownloader, Post
 
-# Паттерны для преобразования embed URL в watch URL
+# Паттерны для распознавания embed URL видеохостингов (whitelist).
+# Если iframe src матчит один из паттернов — это встроенное видео.
 VIDEO_EMBED_PATTERNS = [
-    (r'rutube\.ru/play/embed/([a-f0-9]+)', lambda m: f'https://rutube.ru/video/{m.group(1)}/'),
-    (r'youtube\.com/embed/([^/?]+)', lambda m: f'https://youtube.com/watch?v={m.group(1)}'),
-    (r'youtu\.be/([^/?]+)', lambda m: f'https://youtube.com/watch?v={m.group(1)}'),
-    (r'player\.vimeo\.com/video/(\d+)', lambda m: f'https://vimeo.com/{m.group(1)}'),
-    (r'ok\.ru/videoembed/(\d+)', lambda m: f'https://ok.ru/video/{m.group(1)}'),
-    (r'vk\.com/video_ext\.php\?.*?oid=(-?\d+).*?id=(\d+)', lambda m: f'https://vk.com/video{m.group(1)}_{m.group(2)}'),
+    r'rutube\.ru/play/embed/',
+    r'youtube\.com/embed/',
+    r'player\.vimeo\.com/video/',
+    r'ok\.ru/videoembed/',
+    r'vk\.com/video_ext\.php',
 ]
 
 
@@ -253,28 +253,41 @@ class SponsorDownloader(BaseDownloader):
 
         return assets
 
-    def _parse_video_url(self, embed_src: str) -> str | None:
-        """Преобразует embed URL в watch URL."""
-        for pattern, converter in VIDEO_EMBED_PATTERNS:
-            match = re.search(pattern, embed_src)
-            if match:
-                return converter(match)
-        # Fallback: вернуть оригинальный URL если не распознан
-        if embed_src and ('video' in embed_src or 'embed' in embed_src):
-            return embed_src
-        return None
+    def _is_video_embed(self, src: str) -> bool:
+        """Проверяет, является ли URL embed-ссылкой на известный видеохостинг."""
+        for pattern in VIDEO_EMBED_PATTERNS:
+            if re.search(pattern, src):
+                return True
+        return False
 
     def _replace_video_embeds(self, html_content: str) -> str:
-        """Заменяет iframe/embed видео на markdown-ссылки."""
+        """Заменяет iframe/embed видео на HTML-ссылки.
+        
+        Распознанные видеохостинги → <a href="embed_url">📹 Видео</a>
+        (html2text превратит в markdown-ссылку, Hugo render hook — в iframe).
+        Нераспознанные → текстовая ссылка как fallback.
+        """
         soup = BeautifulSoup(html_content, 'lxml')
 
         for iframe in soup.find_all(['iframe', 'embed']):
             src = iframe.get('src', '')
-            video_url = self._parse_video_url(src)
-            if video_url:
-                placeholder = soup.new_tag('p')
-                placeholder.string = f'📹 Видео: {video_url}'
-                iframe.replace_with(placeholder)
+            if not src:
+                continue
+
+            if self._is_video_embed(src):
+                # Распознанный видеохостинг → ссылка с embed URL
+                link = soup.new_tag('a', href=src)
+                link.string = '\U0001f4f9 Видео'
+                wrapper = soup.new_tag('p')
+                wrapper.append(link)
+                iframe.replace_with(wrapper)
+            elif 'video' in src or 'embed' in src:
+                # Нераспознанный, но похож на видео → текстовая ссылка
+                link = soup.new_tag('a', href=src)
+                link.string = '\U0001f4f9 Видео'
+                wrapper = soup.new_tag('p')
+                wrapper.append(link)
+                iframe.replace_with(wrapper)
 
         return str(soup)
 
@@ -299,7 +312,15 @@ class SponsorDownloader(BaseDownloader):
                     # Разворачиваем внутренний тег, оставляя внешний
                     child.unwrap()
         
-        # 2. Удаляем пустые теги форматирования и выносим пробелы наружу
+        # 2. Слияние соседних <em>/<i> тегов внутри одного родителя.
+        #    <em>вы</em> <b><em>обязаны</em></b> <em>это</em>
+        #    → <em>вы <b>обязаны</b> это</em>
+        #    Это предотвращает фрагментированный курсив после html2text.
+        em_tags = {'em', 'i'}
+        bold_tags = {'b', 'strong'}
+        self._merge_adjacent_em(soup, em_tags, bold_tags)
+        
+        # 3. Удаляем пустые теги форматирования и выносим пробелы наружу
         for tag in list(soup.find_all(['b', 'strong', 'em', 'i'])):
             if tag.parent is None:
                 continue
@@ -323,7 +344,7 @@ class SponsorDownloader(BaseDownloader):
                     last_text.replace_with(last_text.rstrip())
                     tag.insert_after(NavigableString(trailing))
         
-        # 3. Вынос trailing/leading пробелов из <a> тегов наружу
+        # 4. Вынос trailing/leading пробелов из <a> тегов наружу
         #    После выноса пробелов из formatting тегов, пробел может остаться
         #    внутри <a> (но вне <em>/<b>), что даёт [текст ](url) в markdown
         for tag in list(soup.find_all('a')):
@@ -340,6 +361,111 @@ class SponsorDownloader(BaseDownloader):
         
         return str(soup)
 
+    @staticmethod
+    def _merge_adjacent_em(soup, em_tags: set, bold_tags: set):
+        """Объединяет соседние <em>/<i> теги внутри одного родителя.
+        
+        Обрабатывает случаи вида:
+          <em>вы</em> <b><em>обязаны</em></b> <em>это</em>
+        → <em>вы <b>обязаны</b> это</em>
+        
+        Между <em> могут быть:
+        - whitespace (NavigableString из пробелов)
+        - <b>/<strong>, целиком обёрнутые в <em> (<b><em>текст</em></b>)
+        """
+        from bs4 import NavigableString, Tag
+        
+        def is_em(node):
+            """Проверяет, является ли узел тегом em/i."""
+            return isinstance(node, Tag) and node.name in em_tags
+        
+        def is_bold_wrapped_em(node):
+            """Проверяет, является ли узел <b><em>текст</em></b>."""
+            if not isinstance(node, Tag) or node.name not in bold_tags:
+                return False
+            children = list(node.children)
+            return len(children) == 1 and is_em(children[0])
+        
+        def is_whitespace(node):
+            """Проверяет, является ли узел пробельным текстом."""
+            return isinstance(node, NavigableString) and node.strip() == ''
+        
+        # Обходим все элементы, которые могут содержать em-последовательности
+        # Нельзя итерировать напрямую, т.к. дерево мутирует — собираем список родителей
+        parents = set()
+        for em in soup.find_all(list(em_tags)):
+            if em.parent is not None:
+                parents.add(id(em.parent))
+        
+        # Для каждого родителя проверяем его children
+        for parent in list(soup.descendants):
+            if not isinstance(parent, Tag) or id(parent) not in parents:
+                continue
+            
+            # Собираем runs — последовательности соседних em-элементов
+            children = list(parent.children)
+            i = 0
+            while i < len(children):
+                # Ищем начало run: первый <em>
+                if not is_em(children[i]):
+                    i += 1
+                    continue
+                
+                # Собираем run: <em>, whitespace, <b><em>...</em></b>, <em>, ...
+                run_start = i
+                run_nodes = [children[i]]
+                j = i + 1
+                while j < len(children):
+                    node = children[j]
+                    if is_em(node) or is_bold_wrapped_em(node):
+                        run_nodes.append(node)
+                        j += 1
+                    elif is_whitespace(node):
+                        # Пробел между em-элементами — добавляем в run
+                        # но только если за ним следует ещё em/bold-em
+                        if j + 1 < len(children) and (is_em(children[j + 1]) or is_bold_wrapped_em(children[j + 1])):
+                            run_nodes.append(node)
+                            j += 1
+                        else:
+                            break
+                    else:
+                        break
+                
+                # Нужно минимум 2 em-элемента (не считая whitespace) для слияния
+                em_count = sum(1 for n in run_nodes if is_em(n) or is_bold_wrapped_em(n))
+                if em_count < 2:
+                    i = j
+                    continue
+                
+                # Объединяем run в один <em>
+                # Берём первый <em> как базу, переносим в него содержимое остальных
+                first_em = run_nodes[0]
+                
+                for node in run_nodes[1:]:
+                    if is_whitespace(node):
+                        # Пробел → переносим внутрь first_em
+                        ws = NavigableString(str(node))
+                        node.extract()
+                        first_em.append(ws)
+                    elif is_em(node):
+                        # <em>текст</em> → переносим содержимое в first_em
+                        for child in list(node.children):
+                            child.extract()
+                            first_em.append(child)
+                        node.extract()
+                    elif is_bold_wrapped_em(node):
+                        # <b><em>текст</em></b> → <b>текст</b>, переносим в first_em
+                        inner_em = list(node.children)[0]
+                        inner_em.unwrap()  # убираем <em>, оставляя содержимое в <b>
+                        node.extract()
+                        first_em.append(node)
+                
+                # Пересобираем children, т.к. дерево изменилось
+                children = list(parent.children)
+                # Не инкрементируем i — начинаем с того же места
+                # (first_em остался, но children пересобрались)
+                i = children.index(first_em) + 1 if first_em in children else j
+
     @staticmethod
     def _first_navigable_string(tag):
         """Находит первый текстовый узел (NavigableString) внутри тега."""

article_backup-0.3.4/tests/test_boosty_empty_link.py

@@ -0,0 +1,86 @@
+import json
+import unittest
+from unittest.mock import MagicMock, patch
+from pathlib import Path
+
+from src.config import Config, Source, Auth
+from src.database import Database
+from src.boosty import BoostyDownloader
+from src.downloader import Post
+
+
+class BoostyEmptyLinkTests(unittest.TestCase):
+    """Тесты обработки пустых ссылок в Boosty."""
+
+    def setUp(self):
+        self.config = Config(output_dir=Path('/tmp/test'), auth=Auth())
+        self.source = Source(platform='boosty', author='test_author')
+        self.db = MagicMock(spec=Database)
+
+        with patch('src.boosty.load_cookie', return_value='fake_cookie'), \
+             patch('src.boosty.load_auth_header', return_value='Bearer fake_token'):
+            self.downloader = BoostyDownloader(self.config, self.source, self.db)
+
+    def test_empty_link_is_ignored(self):
+        """Ссылка с пустым текстом игнорируется (не превращается в <url>)."""
+        blocks = [
+            # Пустая ссылка (артефакт)
+            {
+                "type": "link",
+                "url": "https://boosty.to/post/1",
+                "content": json.dumps(["", "unstyled", []])
+            },
+            # Нормальная ссылка
+            {
+                "type": "link",
+                "url": "https://boosty.to/post/2",
+                "content": json.dumps(["Вторая часть", "unstyled", []])
+            },
+            # Конец блока (параграфа)
+            {"type": "text", "modificator": "BLOCK_END", "content": ""}
+        ]
+        
+        post = Post(
+            post_id='1', title='Test',
+            content_html=json.dumps(blocks),
+            post_date='2025-01-01', source_url='https://test.com',
+            tags=[], assets=[]
+        )
+
+        result = self.downloader._to_markdown(post, {})
+
+        # Должна быть только текстовая ссылка
+        self.assertIn('[Вторая часть](https://boosty.to/post/2)', result)
+        
+        # Не должно быть артефакта <url>
+        self.assertNotIn('<https://boosty.to/post/1>', result)
+        # Не должно быть пустых скобок
+        self.assertNotIn('[]', result)
+
+    def test_empty_link_does_not_break_paragraph(self):
+        """Пустая ссылка не должна создавать лишние переводы строк."""
+        blocks = [
+            {"type": "text", "content": json.dumps(["Текст до."])},
+            {
+                "type": "link",
+                "url": "https://boosty.to/post/empty",
+                "content": json.dumps(["", "unstyled", []])
+            },
+            {"type": "text", "content": json.dumps(["Текст после."])},
+            {"type": "text", "modificator": "BLOCK_END", "content": ""}
+        ]
+
+        post = Post(
+            post_id='1', title='Test',
+            content_html=json.dumps(blocks),
+            post_date='2025-01-01', source_url='https://test.com',
+            tags=[], assets=[]
+        )
+
+        result = self.downloader._to_markdown(post, {})
+        
+        # Текст должен быть слитным (без разрывов)
+        self.assertEqual(result.strip(), "Текст до.Текст после.")
+
+if __name__ == '__main__':
+    unittest.main()

{article_backup-0.3.3 → article_backup-0.3.4}/tests/test_sponsr_normalize.py

@@ -225,7 +225,8 @@ class SponsorNormalizeTests(unittest.TestCase):
         """Проблема 1: italic + bold-italic внутри ссылки с trailing пробелами.
         
         HTML: «<em>39 лет ... пишу: </em><a href="..."><em>вы </em><b><em>обязаны</em></b><em> это посмотреть</em></a>»
-        Плохо: «_39 лет ... пишу: _[ _вы ****обязаны****это посмотреть_](...)»
+        Плохо: «_39 лет ... пишу: _[ _вы_ ***обязаны*** _это посмотреть_](...)»
+        Хорошо: «_39 лет ... пишу:_ [_вы **обязаны** это посмотреть_](...)»
         """
         post = Post(
             post_id='1',
@@ -243,12 +244,13 @@ class SponsorNormalizeTests(unittest.TestCase):
         self.assertNotIn('****', result)
         # Закрывающий _ не должен иметь пробел перед ним
         self.assertNotIn('пишу: _', result)
-        # Внутри ссылки italic/bold-italic должны быть валидны
-        # Пробел между "вы" и "обязаны" не должен теряться
-        self.assertIn('обязаны', result)
-        self.assertIn('это посмотреть', result)
-        # Не должно быть _[ _вы
-        self.assertNotIn('_[ _', result)
+        # Соседние <em> внутри ссылки объединены в один курсив
+        # Ожидаем: [_вы **обязаны** это посмотреть_](url)
+        self.assertIn('[_вы **обязаны** это посмотреть_]', result)
+        # Не должно быть фрагментированного курсива
+        self.assertNotIn('_вы_', result)
+        self.assertNotIn('***обязаны***', result)
+        self.assertNotIn('_это посмотреть_]', result)
 
     def test_nested_identical_tags_merged(self):
         """Тест слияния вложенных одинаковых тегов: <em><em>text</em></em> → <em>text</em>."""
@@ -305,5 +307,111 @@ class SponsorNormalizeTests(unittest.TestCase):
         self.assertIn('слово', result)
 
 
+    def test_adjacent_em_merged_in_link(self):
+        """Соседние <em> внутри <a> объединяются в один.
+        
+        HTML: <a><em>раз</em> <em>два</em> <em>три</em></a>
+        Хорошо: [_раз два три_](url)
+        Плохо: [_раз_ _два_ _три_](url)
+        """
+        post = Post(
+            post_id='1',
+            title='Test',
+            content_html='<p><a href="https://example.com"><em>раз</em> <em>два</em> <em>три</em></a></p>',
+            post_date='2025-01-01',
+            source_url='https://test.com',
+            tags=[],
+            assets=[]
+        )
+        
+        result = self.downloader._to_markdown(post, {})
+        
+        self.assertIn('[_раз два три_](https://example.com)', result)
+        self.assertNotIn('_раз_', result)
+        self.assertNotIn('_два_', result)
+
+    def test_adjacent_em_merged_in_paragraph(self):
+        """Соседние <em> внутри <p> объединяются в один.
+        
+        HTML: <p>перед <em>курсив1</em> <em>курсив2</em> после</p>
+        Хорошо: перед _курсив1 курсив2_ после
+        Плохо: перед _курсив1_ _курсив2_ после
+        """
+        post = Post(
+            post_id='1',
+            title='Test',
+            content_html='<p>перед <em>курсив1</em> <em>курсив2</em> после</p>',
+            post_date='2025-01-01',
+            source_url='https://test.com',
+            tags=[],
+            assets=[]
+        )
+        
+        result = self.downloader._to_markdown(post, {})
+        
+        self.assertIn('_курсив1 курсив2_', result)
+        self.assertNotIn('_курсив1_', result)
+
+    def test_adjacent_em_with_bold_merged(self):
+        """Соседние <em> с <b><em> между ними объединяются.
+        
+        HTML: <em>раз</em> <b><em>два</em></b> <em>три</em>
+        Хорошо: _раз **два** три_
+        Плохо: _раз_ ***два*** _три_
+        """
+        post = Post(
+            post_id='1',
+            title='Test',
+            content_html='<p><em>раз</em> <b><em>два</em></b> <em>три</em></p>',
+            post_date='2025-01-01',
+            source_url='https://test.com',
+            tags=[],
+            assets=[]
+        )
+        
+        result = self.downloader._to_markdown(post, {})
+        
+        self.assertIn('_раз **два** три_', result)
+        self.assertNotIn('***два***', result)
+
+    def test_single_em_not_affected(self):
+        """Одиночный <em> не затрагивается слиянием."""
+        post = Post(
+            post_id='1',
+            title='Test',
+            content_html='<p>текст <em>курсив</em> обычный</p>',
+            post_date='2025-01-01',
+            source_url='https://test.com',
+            tags=[],
+            assets=[]
+        )
+        
+        result = self.downloader._to_markdown(post, {})
+        
+        self.assertIn('_курсив_', result)
+
+    def test_non_adjacent_em_not_merged(self):
+        """<em> теги, разделённые обычным текстом, не объединяются.
+        
+        HTML: <em>курсив1</em> обычный <em>курсив2</em>
+        Должно остаться: _курсив1_ обычный _курсив2_
+        """
+        post = Post(
+            post_id='1',
+            title='Test',
+            content_html='<p><em>курсив1</em> обычный <em>курсив2</em></p>',
+            post_date='2025-01-01',
+            source_url='https://test.com',
+            tags=[],
+            assets=[]
+        )
+        
+        result = self.downloader._to_markdown(post, {})
+        
+        self.assertIn('_курсив1_', result)
+        self.assertIn('_курсив2_', result)
+        self.assertIn('обычный', result)
+
+
 if __name__ == '__main__':
     unittest.main()

article_backup-0.3.4/tests/test_video_embed.py

@@ -0,0 +1,184 @@
+import json
+import unittest
+from unittest.mock import MagicMock, patch
+from pathlib import Path
+
+from src.config import Config, Source, Auth
+from src.database import Database
+from src.sponsr import SponsorDownloader
+from src.boosty import BoostyDownloader
+from src.downloader import Post
+
+
+class SponsorVideoEmbedTests(unittest.TestCase):
+    """Тесты встраивания видео для Sponsr."""
+
+    def setUp(self):
+        self.config = Config(output_dir=Path('/tmp/test'), auth=Auth())
+        self.source = Source(platform='sponsr', author='test_author')
+        self.db = MagicMock(spec=Database)
+
+        with patch('src.sponsr.load_cookie', return_value='fake_cookie'):
+            self.downloader = SponsorDownloader(self.config, self.source, self.db)
+
+    def _make_post(self, html: str) -> Post:
+        return Post(
+            post_id='1', title='Test', content_html=html,
+            post_date='2025-01-01', source_url='https://test.com',
+            tags=[], assets=[]
+        )
+
+    def test_rutube_iframe_becomes_markdown_link(self):
+        """Rutube iframe → markdown-ссылка с embed URL."""
+        html = '<p>Текст</p><iframe src="https://rutube.ru/play/embed/a1b2c3d4e5f6"></iframe><p>Ещё текст</p>'
+        result = self.downloader._to_markdown(self._make_post(html), {})
+
+        self.assertIn('[📹 Видео](https://rutube.ru/play/embed/a1b2c3d4e5f6)', result)
+        self.assertNotIn('<iframe', result)
+        self.assertNotIn('📹 Видео:', result)  # не текстовый формат
+
+    def test_youtube_iframe_becomes_markdown_link(self):
+        """YouTube iframe → markdown-ссылка с embed URL."""
+        html = '<iframe src="https://www.youtube.com/embed/dQw4w9WgXcQ"></iframe>'
+        result = self.downloader._to_markdown(self._make_post(html), {})
+
+        self.assertIn('[📹 Видео](https://www.youtube.com/embed/dQw4w9WgXcQ)', result)
+
+    def test_vimeo_iframe_becomes_markdown_link(self):
+        """Vimeo iframe → markdown-ссылка с embed URL."""
+        html = '<iframe src="https://player.vimeo.com/video/123456789"></iframe>'
+        result = self.downloader._to_markdown(self._make_post(html), {})
+
+        self.assertIn('[📹 Видео](https://player.vimeo.com/video/123456789)', result)
+
+    def test_ok_ru_iframe_becomes_markdown_link(self):
+        """OK.ru iframe → markdown-ссылка с embed URL."""
+        html = '<iframe src="https://ok.ru/videoembed/987654321"></iframe>'
+        result = self.downloader._to_markdown(self._make_post(html), {})
+
+        self.assertIn('[📹 Видео](https://ok.ru/videoembed/987654321)', result)
+
+    def test_vk_iframe_becomes_markdown_link(self):
+        """VK Video iframe → markdown-ссылка с embed URL."""
+        html = '<iframe src="https://vk.com/video_ext.php?oid=-12345&id=67890&hd=2"></iframe>'
+        result = self.downloader._to_markdown(self._make_post(html), {})
+
+        self.assertIn('[📹 Видео](https://vk.com/video_ext.php?oid=-12345&id=67890&hd=2)', result)
+
+    def test_unknown_video_embed_fallback(self):
+        """Нераспознанный iframe с video/embed в src → markdown-ссылка (fallback)."""
+        html = '<iframe src="https://unknown-host.com/embed/video123"></iframe>'
+        result = self.downloader._to_markdown(self._make_post(html), {})
+
+        # Должна быть markdown-ссылка, а не сырой iframe
+        self.assertIn('[📹 Видео](https://unknown-host.com/embed/video123)', result)
+        self.assertNotIn('<iframe', result)
+
+    def test_non_video_iframe_ignored(self):
+        """iframe без video/embed в src — игнорируется (не заменяется)."""
+        html = '<p>Текст</p><iframe src="https://example.com/widget/form"></iframe><p>Ещё</p>'
+        result = self.downloader._to_markdown(self._make_post(html), {})
+
+        # Не должно быть видео-ссылки
+        self.assertNotIn('📹', result)
+
+    def test_embed_tag_also_converted(self):
+        """Тег <embed> тоже обрабатывается."""
+        html = '<embed src="https://rutube.ru/play/embed/a1b2c3d4e5f6">'
+        result = self.downloader._to_markdown(self._make_post(html), {})
+
+        self.assertIn('[📹 Видео](https://rutube.ru/play/embed/a1b2c3d4e5f6)', result)
+
+    def test_video_link_surrounded_by_text(self):
+        """Видео-ссылка корректно окружена текстом."""
+        html = '<p>Вот видео:</p><iframe src="https://rutube.ru/play/embed/abc123"></iframe><p>А вот продолжение.</p>'
+        result = self.downloader._to_markdown(self._make_post(html), {})
+
+        self.assertIn('Вот видео:', result)
+        self.assertIn('[📹 Видео](https://rutube.ru/play/embed/abc123)', result)
+        self.assertIn('А вот продолжение.', result)
+
+    def test_is_video_embed_recognizes_all_hosts(self):
+        """_is_video_embed распознаёт все хостинги из whitelist."""
+        urls = [
+            'https://rutube.ru/play/embed/abc123',
+            'https://www.youtube.com/embed/xyz789',
+            'https://player.vimeo.com/video/111222',
+            'https://ok.ru/videoembed/333444',
+            'https://vk.com/video_ext.php?oid=-1&id=2',
+        ]
+        for url in urls:
+            self.assertTrue(
+                self.downloader._is_video_embed(url),
+                f"Должен распознать: {url}"
+            )
+
+    def test_is_video_embed_rejects_non_video(self):
+        """_is_video_embed отклоняет обычные URL."""
+        urls = [
+            'https://example.com/page',
+            'https://rutube.ru/video/abc123/',  # watch URL, не embed
+            'https://google.com',
+        ]
+        for url in urls:
+            self.assertFalse(
+                self.downloader._is_video_embed(url),
+                f"Не должен распознать: {url}"
+            )
+
+
+class BoostyVideoEmbedTests(unittest.TestCase):
+    """Тесты встраивания видео для Boosty."""
+
+    def setUp(self):
+        self.config = Config(output_dir=Path('/tmp/test'), auth=Auth())
+        self.source = Source(platform='boosty', author='test_author')
+        self.db = MagicMock(spec=Database)
+
+        with patch('src.boosty.load_cookie', return_value='fake_cookie'), \
+             patch('src.boosty.load_auth_header', return_value='Bearer fake_token'):
+            self.downloader = BoostyDownloader(self.config, self.source, self.db)
+
+    def test_ok_video_becomes_markdown_link(self):
+        """ok_video блок → markdown-ссылка с embed URL."""
+        blocks = [
+            {"type": "ok_video", "id": "123456789"},
+        ]
+        post = Post(
+            post_id='1', title='Test',
+            content_html=json.dumps(blocks),
+            post_date='2025-01-01', source_url='https://test.com',
+            tags=[], assets=[]
+        )
+
+        result = self.downloader._to_markdown(post, {})
+
+        self.assertIn('[📹 Видео](https://ok.ru/videoembed/123456789)', result)
+        # Не должно быть старого формата
+        self.assertNotIn('📹 Видео:', result)
+
+    def test_ok_video_with_surrounding_text(self):
+        """ok_video между текстовыми блоками."""
+        blocks = [
+            {"type": "text", "content": json.dumps(["Посмотрите видео:"])},
+            {"type": "text", "modificator": "BLOCK_END"},
+            {"type": "ok_video", "id": "999888777"},
+            {"type": "text", "content": json.dumps(["Вот такие дела."])},
+            {"type": "text", "modificator": "BLOCK_END"},
+        ]
+        post = Post(
+            post_id='1', title='Test',
+            content_html=json.dumps(blocks),
+            post_date='2025-01-01', source_url='https://test.com',
+            tags=[], assets=[]
+        )
+
+        result = self.downloader._to_markdown(post, {})
+
+        self.assertIn('Посмотрите видео:', result)
+        self.assertIn('[📹 Видео](https://ok.ru/videoembed/999888777)', result)
+        self.assertIn('Вот такие дела.', result)
+
+
+if __name__ == '__main__':
+    unittest.main()