logo

youtube-dl

[mirror] Download/Watch videos from video hostersgit clone https://hacktivis.me/git/mirror/youtube-dl.git

test_YoutubeDL.py (49179B)

    

  1. #!/usr/bin/env python
  2. # coding: utf-8
  4. from __future__ import unicode_literals
  6. # Allow direct execution
  7. import os
  8. import sys
  9. import unittest
  10. sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
  12. import copy
  13. import json
  15. from test.helper import (
  16.     FakeYDL,
  17.     assertRegexpMatches,
  18.     try_rm,
  19. )
  20. from youtube_dl import YoutubeDL
  21. from youtube_dl.compat import (
  22.     compat_http_cookiejar_Cookie,
  23.     compat_http_cookies_SimpleCookie,
  24.     compat_kwargs,
  25.     compat_open as open,
  26.     compat_str,
  27.     compat_urllib_error,
  28. )
  30. from youtube_dl.extractor import YoutubeIE
  31. from youtube_dl.extractor.common import InfoExtractor
  32. from youtube_dl.postprocessor.common import PostProcessor
  33. from youtube_dl.utils import (
  34.     ExtractorError,
  35.     match_filter_func,
  36.     traverse_obj,
  37. )
  39. TEST_URL = 'http://localhost/sample.mp4'
  42. class YDL(FakeYDL):
  43.     def __init__(self, *args, **kwargs):
  44.         super(YDL, self).__init__(*args, **kwargs)
  45.         self.downloaded_info_dicts = []
  46.         self.msgs = []
  48.     def process_info(self, info_dict):
  49.         self.downloaded_info_dicts.append(info_dict.copy())
  51.     def to_screen(self, msg):
  52.         self.msgs.append(msg)
  54.     def dl(self, *args, **kwargs):
  55.         assert False, 'Downloader must not be invoked for test_YoutubeDL'
  58. def _make_result(formats, **kwargs):
  59.     res = {
  60.         'formats': formats,
  61.         'id': 'testid',
  62.         'title': 'testttitle',
  63.         'extractor': 'testex',
  64.         'extractor_key': 'TestEx',
  65.         'webpage_url': 'http://example.com/watch?v=shenanigans',
  66.     }
  67.     res.update(**compat_kwargs(kwargs))
  68.     return res
  71. class TestFormatSelection(unittest.TestCase):
  72.     def test_prefer_free_formats(self):
  73.         # Same resolution => download webm
  74.         ydl = YDL()
  75.         ydl.params['prefer_free_formats'] = True
  76.         formats = [
  77.             {'ext': 'webm', 'height': 460, 'url': TEST_URL},
  78.             {'ext': 'mp4', 'height': 460, 'url': TEST_URL},
  79.         ]
  80.         info_dict = _make_result(formats)
  81.         yie = YoutubeIE(ydl)
  82.         yie._sort_formats(info_dict['formats'])
  83.         ydl.process_ie_result(info_dict)
  84.         downloaded = ydl.downloaded_info_dicts[0]
  85.         self.assertEqual(downloaded['ext'], 'webm')
  87.         # Different resolution => download best quality (mp4)
  88.         ydl = YDL()
  89.         ydl.params['prefer_free_formats'] = True
  90.         formats = [
  91.             {'ext': 'webm', 'height': 720, 'url': TEST_URL},
  92.             {'ext': 'mp4', 'height': 1080, 'url': TEST_URL},
  93.         ]
  94.         info_dict['formats'] = formats
  95.         yie = YoutubeIE(ydl)
  96.         yie._sort_formats(info_dict['formats'])
  97.         ydl.process_ie_result(info_dict)
  98.         downloaded = ydl.downloaded_info_dicts[0]
  99.         self.assertEqual(downloaded['ext'], 'mp4')
  101.         # No prefer_free_formats => prefer mp4 and flv for greater compatibility
  102.         ydl = YDL()
  103.         ydl.params['prefer_free_formats'] = False
  104.         formats = [
  105.             {'ext': 'webm', 'height': 720, 'url': TEST_URL},
  106.             {'ext': 'mp4', 'height': 720, 'url': TEST_URL},
  107.             {'ext': 'flv', 'height': 720, 'url': TEST_URL},
  108.         ]
  109.         info_dict['formats'] = formats
  110.         yie = YoutubeIE(ydl)
  111.         yie._sort_formats(info_dict['formats'])
  112.         ydl.process_ie_result(info_dict)
  113.         downloaded = ydl.downloaded_info_dicts[0]
  114.         self.assertEqual(downloaded['ext'], 'mp4')
  116.         ydl = YDL()
  117.         ydl.params['prefer_free_formats'] = False
  118.         formats = [
  119.             {'ext': 'flv', 'height': 720, 'url': TEST_URL},
  120.             {'ext': 'webm', 'height': 720, 'url': TEST_URL},
  121.         ]
  122.         info_dict['formats'] = formats
  123.         yie = YoutubeIE(ydl)
  124.         yie._sort_formats(info_dict['formats'])
  125.         ydl.process_ie_result(info_dict)
  126.         downloaded = ydl.downloaded_info_dicts[0]
  127.         self.assertEqual(downloaded['ext'], 'flv')
  129.     def test_format_selection(self):
  130.         formats = [
  131.             {'format_id': '35', 'ext': 'mp4', 'preference': 1, 'url': TEST_URL},
  132.             {'format_id': 'example-with-dashes', 'ext': 'webm', 'preference': 1, 'url': TEST_URL},
  133.             {'format_id': '45', 'ext': 'webm', 'preference': 2, 'url': TEST_URL},
  134.             {'format_id': '47', 'ext': 'webm', 'preference': 3, 'url': TEST_URL},
  135.             {'format_id': '2', 'ext': 'flv', 'preference': 4, 'url': TEST_URL},
  136.         ]
  137.         info_dict = _make_result(formats)
  139.         ydl = YDL({'format': '20/47'})
  140.         ydl.process_ie_result(info_dict.copy())
  141.         downloaded = ydl.downloaded_info_dicts[0]
  142.         self.assertEqual(downloaded['format_id'], '47')
  144.         ydl = YDL({'format': '20/71/worst'})
  145.         ydl.process_ie_result(info_dict.copy())
  146.         downloaded = ydl.downloaded_info_dicts[0]
  147.         self.assertEqual(downloaded['format_id'], '35')
  149.         ydl = YDL()
  150.         ydl.process_ie_result(info_dict.copy())
  151.         downloaded = ydl.downloaded_info_dicts[0]
  152.         self.assertEqual(downloaded['format_id'], '2')
  154.         ydl = YDL({'format': 'webm/mp4'})
  155.         ydl.process_ie_result(info_dict.copy())
  156.         downloaded = ydl.downloaded_info_dicts[0]
  157.         self.assertEqual(downloaded['format_id'], '47')
  159.         ydl = YDL({'format': '3gp/40/mp4'})
  160.         ydl.process_ie_result(info_dict.copy())
  161.         downloaded = ydl.downloaded_info_dicts[0]
  162.         self.assertEqual(downloaded['format_id'], '35')
  164.         ydl = YDL({'format': 'example-with-dashes'})
  165.         ydl.process_ie_result(info_dict.copy())
  166.         downloaded = ydl.downloaded_info_dicts[0]
  167.         self.assertEqual(downloaded['format_id'], 'example-with-dashes')
  169.     def test_format_selection_audio(self):
  170.         formats = [
  171.             {'format_id': 'audio-low', 'ext': 'webm', 'preference': 1, 'vcodec': 'none', 'url': TEST_URL},
  172.             {'format_id': 'audio-mid', 'ext': 'webm', 'preference': 2, 'vcodec': 'none', 'url': TEST_URL},
  173.             {'format_id': 'audio-high', 'ext': 'flv', 'preference': 3, 'vcodec': 'none', 'url': TEST_URL},
  174.             {'format_id': 'vid', 'ext': 'mp4', 'preference': 4, 'url': TEST_URL},
  175.         ]
  176.         info_dict = _make_result(formats)
  178.         ydl = YDL({'format': 'bestaudio'})
  179.         ydl.process_ie_result(info_dict.copy())
  180.         downloaded = ydl.downloaded_info_dicts[0]
  181.         self.assertEqual(downloaded['format_id'], 'audio-high')
  183.         ydl = YDL({'format': 'worstaudio'})
  184.         ydl.process_ie_result(info_dict.copy())
  185.         downloaded = ydl.downloaded_info_dicts[0]
  186.         self.assertEqual(downloaded['format_id'], 'audio-low')
  188.         formats = [
  189.             {'format_id': 'vid-low', 'ext': 'mp4', 'preference': 1, 'url': TEST_URL},
  190.             {'format_id': 'vid-high', 'ext': 'mp4', 'preference': 2, 'url': TEST_URL},
  191.         ]
  192.         info_dict = _make_result(formats)
  194.         ydl = YDL({'format': 'bestaudio/worstaudio/best'})
  195.         ydl.process_ie_result(info_dict.copy())
  196.         downloaded = ydl.downloaded_info_dicts[0]
  197.         self.assertEqual(downloaded['format_id'], 'vid-high')
  199.     def test_format_selection_audio_exts(self):
  200.         formats = [
  201.             {'format_id': 'mp3-64', 'ext': 'mp3', 'abr': 64, 'url': 'http://_', 'vcodec': 'none'},
  202.             {'format_id': 'ogg-64', 'ext': 'ogg', 'abr': 64, 'url': 'http://_', 'vcodec': 'none'},
  203.             {'format_id': 'aac-64', 'ext': 'aac', 'abr': 64, 'url': 'http://_', 'vcodec': 'none'},
  204.             {'format_id': 'mp3-32', 'ext': 'mp3', 'abr': 32, 'url': 'http://_', 'vcodec': 'none'},
  205.             {'format_id': 'aac-32', 'ext': 'aac', 'abr': 32, 'url': 'http://_', 'vcodec': 'none'},
  206.         ]
  208.         info_dict = _make_result(formats)
  209.         ydl = YDL({'format': 'best'})
  210.         ie = YoutubeIE(ydl)
  211.         ie._sort_formats(info_dict['formats'])
  212.         ydl.process_ie_result(copy.deepcopy(info_dict))
  213.         downloaded = ydl.downloaded_info_dicts[0]
  214.         self.assertEqual(downloaded['format_id'], 'aac-64')
  216.         ydl = YDL({'format': 'mp3'})
  217.         ie = YoutubeIE(ydl)
  218.         ie._sort_formats(info_dict['formats'])
  219.         ydl.process_ie_result(copy.deepcopy(info_dict))
  220.         downloaded = ydl.downloaded_info_dicts[0]
  221.         self.assertEqual(downloaded['format_id'], 'mp3-64')
  223.         ydl = YDL({'prefer_free_formats': True})
  224.         ie = YoutubeIE(ydl)
  225.         ie._sort_formats(info_dict['formats'])
  226.         ydl.process_ie_result(copy.deepcopy(info_dict))
  227.         downloaded = ydl.downloaded_info_dicts[0]
  228.         self.assertEqual(downloaded['format_id'], 'ogg-64')
  230.     def test_format_selection_video(self):
  231.         formats = [
  232.             {'format_id': 'dash-video-low', 'ext': 'mp4', 'preference': 1, 'acodec': 'none', 'url': TEST_URL},
  233.             {'format_id': 'dash-video-high', 'ext': 'mp4', 'preference': 2, 'acodec': 'none', 'url': TEST_URL},
  234.             {'format_id': 'vid', 'ext': 'mp4', 'preference': 3, 'url': TEST_URL},
  235.         ]
  236.         info_dict = _make_result(formats)
  238.         ydl = YDL({'format': 'bestvideo'})
  239.         ydl.process_ie_result(info_dict.copy())
  240.         downloaded = ydl.downloaded_info_dicts[0]
  241.         self.assertEqual(downloaded['format_id'], 'dash-video-high')
  243.         ydl = YDL({'format': 'worstvideo'})
  244.         ydl.process_ie_result(info_dict.copy())
  245.         downloaded = ydl.downloaded_info_dicts[0]
  246.         self.assertEqual(downloaded['format_id'], 'dash-video-low')
  248.         ydl = YDL({'format': 'bestvideo[format_id^=dash][format_id$=low]'})
  249.         ydl.process_ie_result(info_dict.copy())
  250.         downloaded = ydl.downloaded_info_dicts[0]
  251.         self.assertEqual(downloaded['format_id'], 'dash-video-low')
  253.         formats = [
  254.             {'format_id': 'vid-vcodec-dot', 'ext': 'mp4', 'preference': 1, 'vcodec': 'avc1.123456', 'acodec': 'none', 'url': TEST_URL},
  255.         ]
  256.         info_dict = _make_result(formats)
  258.         ydl = YDL({'format': 'bestvideo[vcodec=avc1.123456]'})
  259.         ydl.process_ie_result(info_dict.copy())
  260.         downloaded = ydl.downloaded_info_dicts[0]
  261.         self.assertEqual(downloaded['format_id'], 'vid-vcodec-dot')
  263.     def test_format_selection_string_ops(self):
  264.         formats = [
  265.             {'format_id': 'abc-cba', 'ext': 'mp4', 'url': TEST_URL},
  266.             {'format_id': 'zxc-cxz', 'ext': 'webm', 'url': TEST_URL},
  267.         ]
  268.         info_dict = _make_result(formats)
  270.         # equals (=)
  271.         ydl = YDL({'format': '[format_id=abc-cba]'})
  272.         ydl.process_ie_result(info_dict.copy())
  273.         downloaded = ydl.downloaded_info_dicts[0]
  274.         self.assertEqual(downloaded['format_id'], 'abc-cba')
  276.         # does not equal (!=)
  277.         ydl = YDL({'format': '[format_id!=abc-cba]'})
  278.         ydl.process_ie_result(info_dict.copy())
  279.         downloaded = ydl.downloaded_info_dicts[0]
  280.         self.assertEqual(downloaded['format_id'], 'zxc-cxz')
  282.         ydl = YDL({'format': '[format_id!=abc-cba][format_id!=zxc-cxz]'})
  283.         self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())
  285.         # starts with (^=)
  286.         ydl = YDL({'format': '[format_id^=abc]'})
  287.         ydl.process_ie_result(info_dict.copy())
  288.         downloaded = ydl.downloaded_info_dicts[0]
  289.         self.assertEqual(downloaded['format_id'], 'abc-cba')
  291.         # does not start with (!^=)
  292.         ydl = YDL({'format': '[format_id!^=abc]'})
  293.         ydl.process_ie_result(info_dict.copy())
  294.         downloaded = ydl.downloaded_info_dicts[0]
  295.         self.assertEqual(downloaded['format_id'], 'zxc-cxz')
  297.         ydl = YDL({'format': '[format_id!^=abc][format_id!^=zxc]'})
  298.         self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())
  300.         # ends with ($=)
  301.         ydl = YDL({'format': '[format_id$=cba]'})
  302.         ydl.process_ie_result(info_dict.copy())
  303.         downloaded = ydl.downloaded_info_dicts[0]
  304.         self.assertEqual(downloaded['format_id'], 'abc-cba')
  306.         # does not end with (!$=)
  307.         ydl = YDL({'format': '[format_id!$=cba]'})
  308.         ydl.process_ie_result(info_dict.copy())
  309.         downloaded = ydl.downloaded_info_dicts[0]
  310.         self.assertEqual(downloaded['format_id'], 'zxc-cxz')
  312.         ydl = YDL({'format': '[format_id!$=cba][format_id!$=cxz]'})
  313.         self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())
  315.         # contains (*=)
  316.         ydl = YDL({'format': '[format_id*=bc-cb]'})
  317.         ydl.process_ie_result(info_dict.copy())
  318.         downloaded = ydl.downloaded_info_dicts[0]
  319.         self.assertEqual(downloaded['format_id'], 'abc-cba')
  321.         # does not contain (!*=)
  322.         ydl = YDL({'format': '[format_id!*=bc-cb]'})
  323.         ydl.process_ie_result(info_dict.copy())
  324.         downloaded = ydl.downloaded_info_dicts[0]
  325.         self.assertEqual(downloaded['format_id'], 'zxc-cxz')
  327.         ydl = YDL({'format': '[format_id!*=abc][format_id!*=zxc]'})
  328.         self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())
  330.         ydl = YDL({'format': '[format_id!*=-]'})
  331.         self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())
  333.     def test_youtube_format_selection(self):
  334.         order = [
  335.             '38', '37', '46', '22', '45', '35', '44', '18', '34', '43', '6', '5', '17', '36', '13',
  336.             # Apple HTTP Live Streaming
  337.             '96', '95', '94', '93', '92', '132', '151',
  338.             # 3D
  339.             '85', '84', '102', '83', '101', '82', '100',
  340.             # Dash video
  341.             '137', '248', '136', '247', '135', '246',
  342.             '245', '244', '134', '243', '133', '242', '160',
  343.             # Dash audio
  344.             '141', '172', '140', '171', '139',
  345.         ]
  347.         def format_info(f_id):
  348.             info = YoutubeIE._formats[f_id].copy()
  350.             # XXX: In real cases InfoExtractor._parse_mpd_formats() fills up 'acodec'
  351.             # and 'vcodec', while in tests such information is incomplete since
  352.             # commit a6c2c24479e5f4827ceb06f64d855329c0a6f593
  353.             # test_YoutubeDL.test_youtube_format_selection is broken without
  354.             # this fix
  355.             if 'acodec' in info and 'vcodec' not in info:
  356.                 info['vcodec'] = 'none'
  357.             elif 'vcodec' in info and 'acodec' not in info:
  358.                 info['acodec'] = 'none'
  360.             info['format_id'] = f_id
  361.             info['url'] = 'url:' + f_id
  362.             return info
  363.         formats_order = [format_info(f_id) for f_id in order]
  365.         info_dict = _make_result(list(formats_order), extractor='youtube')
  366.         ydl = YDL({'format': 'bestvideo+bestaudio'})
  367.         yie = YoutubeIE(ydl)
  368.         yie._sort_formats(info_dict['formats'])
  369.         ydl.process_ie_result(info_dict)
  370.         downloaded = ydl.downloaded_info_dicts[0]
  371.         self.assertEqual(downloaded['format_id'], '137+141')
  372.         self.assertEqual(downloaded['ext'], 'mp4')
  374.         info_dict = _make_result(list(formats_order), extractor='youtube')
  375.         ydl = YDL({'format': 'bestvideo[height>=999999]+bestaudio/best'})
  376.         yie = YoutubeIE(ydl)
  377.         yie._sort_formats(info_dict['formats'])
  378.         ydl.process_ie_result(info_dict)
  379.         downloaded = ydl.downloaded_info_dicts[0]
  380.         self.assertEqual(downloaded['format_id'], '38')
  382.         info_dict = _make_result(list(formats_order), extractor='youtube')
  383.         ydl = YDL({'format': 'bestvideo/best,bestaudio'})
  384.         yie = YoutubeIE(ydl)
  385.         yie._sort_formats(info_dict['formats'])
  386.         ydl.process_ie_result(info_dict)
  387.         downloaded_ids = [info['format_id'] for info in ydl.downloaded_info_dicts]
  388.         self.assertEqual(downloaded_ids, ['137', '141'])
  390.         info_dict = _make_result(list(formats_order), extractor='youtube')
  391.         ydl = YDL({'format': '(bestvideo[ext=mp4],bestvideo[ext=webm])+bestaudio'})
  392.         yie = YoutubeIE(ydl)
  393.         yie._sort_formats(info_dict['formats'])
  394.         ydl.process_ie_result(info_dict)
  395.         downloaded_ids = [info['format_id'] for info in ydl.downloaded_info_dicts]
  396.         self.assertEqual(downloaded_ids, ['137+141', '248+141'])
  398.         info_dict = _make_result(list(formats_order), extractor='youtube')
  399.         ydl = YDL({'format': '(bestvideo[ext=mp4],bestvideo[ext=webm])[height<=720]+bestaudio'})
  400.         yie = YoutubeIE(ydl)
  401.         yie._sort_formats(info_dict['formats'])
  402.         ydl.process_ie_result(info_dict)
  403.         downloaded_ids = [info['format_id'] for info in ydl.downloaded_info_dicts]
  404.         self.assertEqual(downloaded_ids, ['136+141', '247+141'])
  406.         info_dict = _make_result(list(formats_order), extractor='youtube')
  407.         ydl = YDL({'format': '(bestvideo[ext=none]/bestvideo[ext=webm])+bestaudio'})
  408.         yie = YoutubeIE(ydl)
  409.         yie._sort_formats(info_dict['formats'])
  410.         ydl.process_ie_result(info_dict)
  411.         downloaded_ids = [info['format_id'] for info in ydl.downloaded_info_dicts]
  412.         self.assertEqual(downloaded_ids, ['248+141'])
  414.         for f1, f2 in zip(formats_order, formats_order[1:]):
  415.             info_dict = _make_result([f1, f2], extractor='youtube')
  416.             ydl = YDL({'format': 'best/bestvideo'})
  417.             yie = YoutubeIE(ydl)
  418.             yie._sort_formats(info_dict['formats'])
  419.             ydl.process_ie_result(info_dict)
  420.             downloaded = ydl.downloaded_info_dicts[0]
  421.             self.assertEqual(downloaded['format_id'], f1['format_id'])
  423.             info_dict = _make_result([f2, f1], extractor='youtube')
  424.             ydl = YDL({'format': 'best/bestvideo'})
  425.             yie = YoutubeIE(ydl)
  426.             yie._sort_formats(info_dict['formats'])
  427.             ydl.process_ie_result(info_dict)
  428.             downloaded = ydl.downloaded_info_dicts[0]
  429.             self.assertEqual(downloaded['format_id'], f1['format_id'])
  431.     def test_audio_only_extractor_format_selection(self):
  432.         # For extractors with incomplete formats (all formats are audio-only or
  433.         # video-only) best and worst should fallback to corresponding best/worst
  434.         # video-only or audio-only formats (as per
  435.         # https://github.com/ytdl-org/youtube-dl/pull/5556)
  436.         formats = [
  437.             {'format_id': 'low', 'ext': 'mp3', 'preference': 1, 'vcodec': 'none', 'url': TEST_URL},
  438.             {'format_id': 'high', 'ext': 'mp3', 'preference': 2, 'vcodec': 'none', 'url': TEST_URL},
  439.         ]
  440.         info_dict = _make_result(formats)
  442.         ydl = YDL({'format': 'best'})
  443.         ydl.process_ie_result(info_dict.copy())
  444.         downloaded = ydl.downloaded_info_dicts[0]
  445.         self.assertEqual(downloaded['format_id'], 'high')
  447.         ydl = YDL({'format': 'worst'})
  448.         ydl.process_ie_result(info_dict.copy())
  449.         downloaded = ydl.downloaded_info_dicts[0]
  450.         self.assertEqual(downloaded['format_id'], 'low')
  452.     def test_format_not_available(self):
  453.         formats = [
  454.             {'format_id': 'regular', 'ext': 'mp4', 'height': 360, 'url': TEST_URL},
  455.             {'format_id': 'video', 'ext': 'mp4', 'height': 720, 'acodec': 'none', 'url': TEST_URL},
  456.         ]
  457.         info_dict = _make_result(formats)
  459.         # This must fail since complete video-audio format does not match filter
  460.         # and extractor does not provide incomplete only formats (i.e. only
  461.         # video-only or audio-only).
  462.         ydl = YDL({'format': 'best[height>360]'})
  463.         self.assertRaises(ExtractorError, ydl.process_ie_result, info_dict.copy())
  465.     def test_format_selection_issue_10083(self):
  466.         # See https://github.com/ytdl-org/youtube-dl/issues/10083
  467.         formats = [
  468.             {'format_id': 'regular', 'height': 360, 'url': TEST_URL},
  469.             {'format_id': 'video', 'height': 720, 'acodec': 'none', 'url': TEST_URL},
  470.             {'format_id': 'audio', 'vcodec': 'none', 'url': TEST_URL},
  471.         ]
  472.         info_dict = _make_result(formats)
  474.         ydl = YDL({'format': 'best[height>360]/bestvideo[height>360]+bestaudio'})
  475.         ydl.process_ie_result(info_dict.copy())
  476.         self.assertEqual(ydl.downloaded_info_dicts[0]['format_id'], 'video+audio')
  478.     def test_invalid_format_specs(self):
  479.         def assert_syntax_error(format_spec):
  480.             ydl = YDL({'format': format_spec})
  481.             info_dict = _make_result([{'format_id': 'foo', 'url': TEST_URL}])
  482.             self.assertRaises(SyntaxError, ydl.process_ie_result, info_dict)
  484.         assert_syntax_error('bestvideo,,best')
  485.         assert_syntax_error('+bestaudio')
  486.         assert_syntax_error('bestvideo+')
  487.         assert_syntax_error('/')
  488.         assert_syntax_error('bestvideo+bestvideo+bestaudio')
  490.     def test_format_filtering(self):
  491.         formats = [
  492.             {'format_id': 'A', 'filesize': 500, 'width': 1000},
  493.             {'format_id': 'B', 'filesize': 1000, 'width': 500},
  494.             {'format_id': 'C', 'filesize': 1000, 'width': 400},
  495.             {'format_id': 'D', 'filesize': 2000, 'width': 600},
  496.             {'format_id': 'E', 'filesize': 3000},
  497.             {'format_id': 'F'},
  498.             {'format_id': 'G', 'filesize': 1000000},
  499.         ]
  500.         for f in formats:
  501.             f['url'] = 'http://_/'
  502.             f['ext'] = 'unknown'
  503.         info_dict = _make_result(formats)
  505.         ydl = YDL({'format': 'best[filesize<3000]'})
  506.         ydl.process_ie_result(info_dict)
  507.         downloaded = ydl.downloaded_info_dicts[0]
  508.         self.assertEqual(downloaded['format_id'], 'D')
  510.         ydl = YDL({'format': 'best[filesize<=3000]'})
  511.         ydl.process_ie_result(info_dict)
  512.         downloaded = ydl.downloaded_info_dicts[0]
  513.         self.assertEqual(downloaded['format_id'], 'E')
  515.         ydl = YDL({'format': 'best[filesize <= ? 3000]'})
  516.         ydl.process_ie_result(info_dict)
  517.         downloaded = ydl.downloaded_info_dicts[0]
  518.         self.assertEqual(downloaded['format_id'], 'F')
  520.         ydl = YDL({'format': 'best [filesize = 1000] [width>450]'})
  521.         ydl.process_ie_result(info_dict)
  522.         downloaded = ydl.downloaded_info_dicts[0]
  523.         self.assertEqual(downloaded['format_id'], 'B')
  525.         ydl = YDL({'format': 'best [filesize = 1000] [width!=450]'})
  526.         ydl.process_ie_result(info_dict)
  527.         downloaded = ydl.downloaded_info_dicts[0]
  528.         self.assertEqual(downloaded['format_id'], 'C')
  530.         ydl = YDL({'format': '[filesize>?1]'})
  531.         ydl.process_ie_result(info_dict)
  532.         downloaded = ydl.downloaded_info_dicts[0]
  533.         self.assertEqual(downloaded['format_id'], 'G')
  535.         ydl = YDL({'format': '[filesize<1M]'})
  536.         ydl.process_ie_result(info_dict)
  537.         downloaded = ydl.downloaded_info_dicts[0]
  538.         self.assertEqual(downloaded['format_id'], 'E')
  540.         ydl = YDL({'format': '[filesize<1MiB]'})
  541.         ydl.process_ie_result(info_dict)
  542.         downloaded = ydl.downloaded_info_dicts[0]
  543.         self.assertEqual(downloaded['format_id'], 'G')
  545.         ydl = YDL({'format': 'all[width>=400][width<=600]'})
  546.         ydl.process_ie_result(info_dict)
  547.         downloaded_ids = [info['format_id'] for info in ydl.downloaded_info_dicts]
  548.         self.assertEqual(downloaded_ids, ['B', 'C', 'D'])
  550.         ydl = YDL({'format': 'best[height<40]'})
  551.         try:
  552.             ydl.process_ie_result(info_dict)
  553.         except ExtractorError:
  554.             pass
  555.         self.assertEqual(ydl.downloaded_info_dicts, [])
  557.     def test_default_format_spec(self):
  558.         ydl = YDL({'simulate': True})
  559.         self.assertEqual(ydl._default_format_spec({}), 'bestvideo+bestaudio/best')
  561.         ydl = YDL({})
  562.         self.assertEqual(ydl._default_format_spec({'is_live': True}), 'best/bestvideo+bestaudio')
  564.         ydl = YDL({'simulate': True})
  565.         self.assertEqual(ydl._default_format_spec({'is_live': True}), 'bestvideo+bestaudio/best')
  567.         ydl = YDL({'outtmpl': '-'})
  568.         self.assertEqual(ydl._default_format_spec({}), 'best/bestvideo+bestaudio')
  570.         ydl = YDL({})
  571.         self.assertEqual(ydl._default_format_spec({}, download=False), 'bestvideo+bestaudio/best')
  572.         self.assertEqual(ydl._default_format_spec({'is_live': True}), 'best/bestvideo+bestaudio')
  575. class TestYoutubeDL(unittest.TestCase):
  576.     def test_subtitles(self):
  577.         def s_formats(lang, autocaption=False):
  578.             return [{
  579.                 'ext': ext,
  580.                 'url': 'http://localhost/video.%s.%s' % (lang, ext),
  581.                 '_auto': autocaption,
  582.             } for ext in ['vtt', 'srt', 'ass']]
  583.         subtitles = dict((l, s_formats(l)) for l in ['en', 'fr', 'es'])
  584.         auto_captions = dict((l, s_formats(l, True)) for l in ['it', 'pt', 'es'])
  585.         info_dict = {
  586.             'id': 'test',
  587.             'title': 'Test',
  588.             'url': 'http://localhost/video.mp4',
  589.             'subtitles': subtitles,
  590.             'automatic_captions': auto_captions,
  591.             'extractor': 'TEST',
  592.         }
  594.         def get_info(params={}):
  595.             params.setdefault('simulate', True)
  596.             ydl = YDL(params)
  597.             ydl.report_warning = lambda *args, **kargs: None
  598.             return ydl.process_video_result(info_dict, download=False)
  600.         result = get_info()
  601.         self.assertFalse(result.get('requested_subtitles'))
  602.         self.assertEqual(result['subtitles'], subtitles)
  603.         self.assertEqual(result['automatic_captions'], auto_captions)
  605.         result = get_info({'writesubtitles': True})
  606.         subs = result['requested_subtitles']
  607.         self.assertTrue(subs)
  608.         self.assertEqual(set(subs.keys()), set(['en']))
  609.         self.assertTrue(subs['en'].get('data') is None)
  610.         self.assertEqual(subs['en']['ext'], 'ass')
  612.         result = get_info({'writesubtitles': True, 'subtitlesformat': 'foo/srt'})
  613.         subs = result['requested_subtitles']
  614.         self.assertEqual(subs['en']['ext'], 'srt')
  616.         result = get_info({'writesubtitles': True, 'subtitleslangs': ['es', 'fr', 'it']})
  617.         subs = result['requested_subtitles']
  618.         self.assertTrue(subs)
  619.         self.assertEqual(set(subs.keys()), set(['es', 'fr']))
  621.         result = get_info({'writesubtitles': True, 'writeautomaticsub': True, 'subtitleslangs': ['es', 'pt']})
  622.         subs = result['requested_subtitles']
  623.         self.assertTrue(subs)
  624.         self.assertEqual(set(subs.keys()), set(['es', 'pt']))
  625.         self.assertFalse(subs['es']['_auto'])
  626.         self.assertTrue(subs['pt']['_auto'])
  628.         result = get_info({'writeautomaticsub': True, 'subtitleslangs': ['es', 'pt']})
  629.         subs = result['requested_subtitles']
  630.         self.assertTrue(subs)
  631.         self.assertEqual(set(subs.keys()), set(['es', 'pt']))
  632.         self.assertTrue(subs['es']['_auto'])
  633.         self.assertTrue(subs['pt']['_auto'])
  635.     def test_add_extra_info(self):
  636.         test_dict = {
  637.             'extractor': 'Foo',
  638.         }
  639.         extra_info = {
  640.             'extractor': 'Bar',
  641.             'playlist': 'funny videos',
  642.         }
  643.         YDL.add_extra_info(test_dict, extra_info)
  644.         self.assertEqual(test_dict['extractor'], 'Foo')
  645.         self.assertEqual(test_dict['playlist'], 'funny videos')
  647.     def test_prepare_filename(self):
  648.         info = {
  649.             'id': '1234',
  650.             'ext': 'mp4',
  651.             'width': None,
  652.             'height': 1080,
  653.             'title1': '$PATH',
  654.             'title2': '%PATH%',
  655.         }
  657.         def fname(templ, na_placeholder='NA'):
  658.             params = {'outtmpl': templ}
  659.             if na_placeholder != 'NA':
  660.                 params['outtmpl_na_placeholder'] = na_placeholder
  661.             ydl = YoutubeDL(params)
  662.             return ydl.prepare_filename(info)
  663.         self.assertEqual(fname('%(id)s.%(ext)s'), '1234.mp4')
  664.         self.assertEqual(fname('%(id)s-%(width)s.%(ext)s'), '1234-NA.mp4')
  665.         NA_TEST_OUTTMPL = '%(uploader_date)s-%(width)d-%(id)s.%(ext)s'
  666.         # Replace missing fields with 'NA' by default
  667.         self.assertEqual(fname(NA_TEST_OUTTMPL), 'NA-NA-1234.mp4')
  668.         # Or by provided placeholder
  669.         self.assertEqual(fname(NA_TEST_OUTTMPL, na_placeholder='none'), 'none-none-1234.mp4')
  670.         self.assertEqual(fname(NA_TEST_OUTTMPL, na_placeholder=''), '--1234.mp4')
  671.         self.assertEqual(fname('%(height)d.%(ext)s'), '1080.mp4')
  672.         self.assertEqual(fname('%(height)6d.%(ext)s'), '  1080.mp4')
  673.         self.assertEqual(fname('%(height)-6d.%(ext)s'), '1080  .mp4')
  674.         self.assertEqual(fname('%(height)06d.%(ext)s'), '001080.mp4')
  675.         self.assertEqual(fname('%(height) 06d.%(ext)s'), ' 01080.mp4')
  676.         self.assertEqual(fname('%(height)   06d.%(ext)s'), ' 01080.mp4')
  677.         self.assertEqual(fname('%(height)0 6d.%(ext)s'), ' 01080.mp4')
  678.         self.assertEqual(fname('%(height)0   6d.%(ext)s'), ' 01080.mp4')
  679.         self.assertEqual(fname('%(height)   0   6d.%(ext)s'), ' 01080.mp4')
  680.         self.assertEqual(fname('%%'), '%')
  681.         self.assertEqual(fname('%%%%'), '%%')
  682.         self.assertEqual(fname('%%(height)06d.%(ext)s'), '%(height)06d.mp4')
  683.         self.assertEqual(fname('%(width)06d.%(ext)s'), 'NA.mp4')
  684.         self.assertEqual(fname('%(width)06d.%%(ext)s'), 'NA.%(ext)s')
  685.         self.assertEqual(fname('%%(width)06d.%(ext)s'), '%(width)06d.mp4')
  686.         self.assertEqual(fname('Hello %(title1)s'), 'Hello $PATH')
  687.         self.assertEqual(fname('Hello %(title2)s'), 'Hello %PATH%')
  689.     def test_format_note(self):
  690.         ydl = YoutubeDL()
  691.         self.assertEqual(ydl._format_note({}), '')
  692.         assertRegexpMatches(self, ydl._format_note({
  693.             'vbr': 10,
  694.         }), r'^\s*10k$')
  695.         assertRegexpMatches(self, ydl._format_note({
  696.             'fps': 30,
  697.         }), r'^30fps$')
  699.     def test_postprocessors(self):
  700.         filename = 'post-processor-testfile.mp4'
  701.         audiofile = filename + '.mp3'
  703.         class SimplePP(PostProcessor):
  704.             def run(self, info):
  705.                 with open(audiofile, 'w') as f:
  706.                     f.write('EXAMPLE')
  707.                 return [info['filepath']], info
  709.         def run_pp(params, PP):
  710.             with open(filename, 'w') as f:
  711.                 f.write('EXAMPLE')
  712.             ydl = YoutubeDL(params)
  713.             ydl.add_post_processor(PP())
  714.             ydl.post_process(filename, {'filepath': filename})
  716.         run_pp({'keepvideo': True}, SimplePP)
  717.         self.assertTrue(os.path.exists(filename), '%s doesn\'t exist' % filename)
  718.         self.assertTrue(os.path.exists(audiofile), '%s doesn\'t exist' % audiofile)
  719.         os.unlink(filename)
  720.         os.unlink(audiofile)
  722.         run_pp({'keepvideo': False}, SimplePP)
  723.         self.assertFalse(os.path.exists(filename), '%s exists' % filename)
  724.         self.assertTrue(os.path.exists(audiofile), '%s doesn\'t exist' % audiofile)
  725.         os.unlink(audiofile)
  727.         class ModifierPP(PostProcessor):
  728.             def run(self, info):
  729.                 with open(info['filepath'], 'w') as f:
  730.                     f.write('MODIFIED')
  731.                 return [], info
  733.         run_pp({'keepvideo': False}, ModifierPP)
  734.         self.assertTrue(os.path.exists(filename), '%s doesn\'t exist' % filename)
  735.         os.unlink(filename)
  737.     def test_match_filter(self):
  738.         class FilterYDL(YDL):
  739.             def __init__(self, *args, **kwargs):
  740.                 super(FilterYDL, self).__init__(*args, **kwargs)
  741.                 self.params['simulate'] = True
  743.             def process_info(self, info_dict):
  744.                 super(YDL, self).process_info(info_dict)
  746.             def _match_entry(self, info_dict, incomplete):
  747.                 res = super(FilterYDL, self)._match_entry(info_dict, incomplete)
  748.                 if res is None:
  749.                     self.downloaded_info_dicts.append(info_dict)
  750.                 return res
  752.         first = {
  753.             'id': '1',
  754.             'url': TEST_URL,
  755.             'title': 'one',
  756.             'extractor': 'TEST',
  757.             'duration': 30,
  758.             'filesize': 10 * 1024,
  759.             'playlist_id': '42',
  760.             'uploader': "變態妍字幕版 太妍 тест",
  761.             'creator': "тест ' 123 ' тест--",
  762.         }
  763.         second = {
  764.             'id': '2',
  765.             'url': TEST_URL,
  766.             'title': 'two',
  767.             'extractor': 'TEST',
  768.             'duration': 10,
  769.             'description': 'foo',
  770.             'filesize': 5 * 1024,
  771.             'playlist_id': '43',
  772.             'uploader': "тест 123",
  773.         }
  774.         videos = [first, second]
  776.         def get_videos(filter_=None):
  777.             ydl = FilterYDL({'match_filter': filter_})
  778.             for v in videos:
  779.                 ydl.process_ie_result(v, download=True)
  780.             return [v['id'] for v in ydl.downloaded_info_dicts]
  782.         res = get_videos()
  783.         self.assertEqual(res, ['1', '2'])
  785.         def f(v):
  786.             if v['id'] == '1':
  787.                 return None
  788.             else:
  789.                 return 'Video id is not 1'
  790.         res = get_videos(f)
  791.         self.assertEqual(res, ['1'])
  793.         f = match_filter_func('duration < 30')
  794.         res = get_videos(f)
  795.         self.assertEqual(res, ['2'])
  797.         f = match_filter_func('description = foo')
  798.         res = get_videos(f)
  799.         self.assertEqual(res, ['2'])
  801.         f = match_filter_func('description =? foo')
  802.         res = get_videos(f)
  803.         self.assertEqual(res, ['1', '2'])
  805.         f = match_filter_func('filesize > 5KiB')
  806.         res = get_videos(f)
  807.         self.assertEqual(res, ['1'])
  809.         f = match_filter_func('playlist_id = 42')
  810.         res = get_videos(f)
  811.         self.assertEqual(res, ['1'])
  813.         f = match_filter_func('uploader = "變態妍字幕版 太妍 тест"')
  814.         res = get_videos(f)
  815.         self.assertEqual(res, ['1'])
  817.         f = match_filter_func('uploader != "變態妍字幕版 太妍 тест"')
  818.         res = get_videos(f)
  819.         self.assertEqual(res, ['2'])
  821.         f = match_filter_func('creator = "тест \' 123 \' тест--"')
  822.         res = get_videos(f)
  823.         self.assertEqual(res, ['1'])
  825.         f = match_filter_func("creator = 'тест \\' 123 \\' тест--'")
  826.         res = get_videos(f)
  827.         self.assertEqual(res, ['1'])
  829.         f = match_filter_func(r"creator = 'тест \' 123 \' тест--' & duration > 30")
  830.         res = get_videos(f)
  831.         self.assertEqual(res, [])
  833.     def test_playlist_items_selection(self):
  834.         entries = [{
  835.             'id': compat_str(i),
  836.             'title': compat_str(i),
  837.             'url': TEST_URL,
  838.         } for i in range(1, 5)]
  839.         playlist = {
  840.             '_type': 'playlist',
  841.             'id': 'test',
  842.             'entries': entries,
  843.             'extractor': 'test:playlist',
  844.             'extractor_key': 'test:playlist',
  845.             'webpage_url': 'http://example.com',
  846.         }
  848.         def get_downloaded_info_dicts(params):
  849.             ydl = YDL(params)
  850.             # make a deep copy because the dictionary and nested entries
  851.             # can be modified
  852.             ydl.process_ie_result(copy.deepcopy(playlist))
  853.             return ydl.downloaded_info_dicts
  855.         def get_ids(params):
  856.             return [int(v['id']) for v in get_downloaded_info_dicts(params)]
  858.         result = get_ids({})
  859.         self.assertEqual(result, [1, 2, 3, 4])
  861.         result = get_ids({'playlistend': 10})
  862.         self.assertEqual(result, [1, 2, 3, 4])
  864.         result = get_ids({'playlistend': 2})
  865.         self.assertEqual(result, [1, 2])
  867.         result = get_ids({'playliststart': 10})
  868.         self.assertEqual(result, [])
  870.         result = get_ids({'playliststart': 2})
  871.         self.assertEqual(result, [2, 3, 4])
  873.         result = get_ids({'playlist_items': '2-4'})
  874.         self.assertEqual(result, [2, 3, 4])
  876.         result = get_ids({'playlist_items': '2,4'})
  877.         self.assertEqual(result, [2, 4])
  879.         result = get_ids({'playlist_items': '10'})
  880.         self.assertEqual(result, [])
  882.         result = get_ids({'playlist_items': '3-10'})
  883.         self.assertEqual(result, [3, 4])
  885.         result = get_ids({'playlist_items': '2-4,3-4,3'})
  886.         self.assertEqual(result, [2, 3, 4])
  888.         # Tests for https://github.com/ytdl-org/youtube-dl/issues/10591
  889.         # @{
  890.         result = get_downloaded_info_dicts({'playlist_items': '2-4,3-4,3'})
  891.         self.assertEqual(result[0]['playlist_index'], 2)
  892.         self.assertEqual(result[1]['playlist_index'], 3)
  894.         result = get_downloaded_info_dicts({'playlist_items': '2-4,3-4,3'})
  895.         self.assertEqual(result[0]['playlist_index'], 2)
  896.         self.assertEqual(result[1]['playlist_index'], 3)
  897.         self.assertEqual(result[2]['playlist_index'], 4)
  899.         result = get_downloaded_info_dicts({'playlist_items': '4,2'})
  900.         self.assertEqual(result[0]['playlist_index'], 4)
  901.         self.assertEqual(result[1]['playlist_index'], 2)
  902.         # @}
  904.     def test_urlopen_no_file_protocol(self):
  905.         # see https://github.com/ytdl-org/youtube-dl/issues/8227
  906.         ydl = YDL()
  907.         self.assertRaises(compat_urllib_error.URLError, ydl.urlopen, 'file:///etc/passwd')
  909.     def test_do_not_override_ie_key_in_url_transparent(self):
  910.         ydl = YDL()
  912.         class Foo1IE(InfoExtractor):
  913.             _VALID_URL = r'foo1:'
  915.             def _real_extract(self, url):
  916.                 return {
  917.                     '_type': 'url_transparent',
  918.                     'url': 'foo2:',
  919.                     'ie_key': 'Foo2',
  920.                     'title': 'foo1 title',
  921.                     'id': 'foo1_id',
  922.                 }
  924.         class Foo2IE(InfoExtractor):
  925.             _VALID_URL = r'foo2:'
  927.             def _real_extract(self, url):
  928.                 return {
  929.                     '_type': 'url',
  930.                     'url': 'foo3:',
  931.                     'ie_key': 'Foo3',
  932.                 }
  934.         class Foo3IE(InfoExtractor):
  935.             _VALID_URL = r'foo3:'
  937.             def _real_extract(self, url):
  938.                 return _make_result([{'url': TEST_URL}], title='foo3 title')
  940.         ydl.add_info_extractor(Foo1IE(ydl))
  941.         ydl.add_info_extractor(Foo2IE(ydl))
  942.         ydl.add_info_extractor(Foo3IE(ydl))
  943.         ydl.extract_info('foo1:')
  944.         downloaded = ydl.downloaded_info_dicts[0]
  945.         self.assertEqual(downloaded['url'], TEST_URL)
  946.         self.assertEqual(downloaded['title'], 'foo1 title')
  947.         self.assertEqual(downloaded['id'], 'testid')
  948.         self.assertEqual(downloaded['extractor'], 'testex')
  949.         self.assertEqual(downloaded['extractor_key'], 'TestEx')
  951.     # Test case for https://github.com/ytdl-org/youtube-dl/issues/27064
  952.     def test_ignoreerrors_for_playlist_with_url_transparent_iterable_entries(self):
  954.         ydl = YDL({
  955.             'format': 'extra',
  956.             'ignoreerrors': True,
  957.         })
  958.         ydl.trouble = lambda *_, **__: None
  960.         class VideoIE(InfoExtractor):
  961.             _VALID_URL = r'video:(?P<id>\d+)'
  963.             def _real_extract(self, url):
  964.                 video_id = self._match_id(url)
  965.                 formats = [{
  966.                     'format_id': 'default',
  967.                     'url': 'url:',
  968.                 }]
  969.                 if video_id == '0':
  970.                     raise ExtractorError('foo')
  971.                 if video_id == '2':
  972.                     formats.append({
  973.                         'format_id': 'extra',
  974.                         'url': TEST_URL,
  975.                     })
  976.                 return {
  977.                     'id': video_id,
  978.                     'title': 'Video %s' % video_id,
  979.                     'formats': formats,
  980.                 }
  982.         class PlaylistIE(InfoExtractor):
  983.             _VALID_URL = r'playlist:'
  985.             def _entries(self):
  986.                 for n in range(3):
  987.                     video_id = compat_str(n)
  988.                     yield {
  989.                         '_type': 'url_transparent',
  990.                         'ie_key': VideoIE.ie_key(),
  991.                         'id': video_id,
  992.                         'url': 'video:%s' % video_id,
  993.                         'title': 'Video Transparent %s' % video_id,
  994.                     }
  996.             def _real_extract(self, url):
  997.                 return self.playlist_result(self._entries())
  999.         ydl.add_info_extractor(VideoIE(ydl))
  1000.         ydl.add_info_extractor(PlaylistIE(ydl))
  1001.         info = ydl.extract_info('playlist:')
  1002.         entries = info['entries']
  1003.         self.assertEqual(len(entries), 3)
  1004.         self.assertTrue(entries[0] is None)
  1005.         self.assertTrue(entries[1] is None)
  1006.         self.assertEqual(len(ydl.downloaded_info_dicts), 1)
  1007.         downloaded = ydl.downloaded_info_dicts[0]
  1008.         self.assertEqual(entries[2], downloaded)
  1009.         self.assertEqual(downloaded['url'], TEST_URL)
  1010.         self.assertEqual(downloaded['title'], 'Video Transparent 2')
  1011.         self.assertEqual(downloaded['id'], '2')
  1012.         self.assertEqual(downloaded['extractor'], 'Video')
  1013.         self.assertEqual(downloaded['extractor_key'], 'Video')
  1015.     def test_default_times(self):
  1016.         """Test addition of missing upload/release/_date from /release_/timestamp"""
  1017.         info = {
  1018.             'id': '1234',
  1019.             'url': TEST_URL,
  1020.             'title': 'Title',
  1021.             'ext': 'mp4',
  1022.             'timestamp': 1631352900,
  1023.             'release_timestamp': 1632995931,
  1024.         }
  1026.         params = {'simulate': True, }
  1027.         ydl = FakeYDL(params)
  1028.         out_info = ydl.process_ie_result(info)
  1029.         self.assertTrue(isinstance(out_info['upload_date'], compat_str))
  1030.         self.assertEqual(out_info['upload_date'], '20210911')
  1031.         self.assertTrue(isinstance(out_info['release_date'], compat_str))
  1032.         self.assertEqual(out_info['release_date'], '20210930')
  1035. class TestYoutubeDLCookies(unittest.TestCase):
  1037.     @staticmethod
  1038.     def encode_cookie(cookie):
  1039.         if not isinstance(cookie, dict):
  1040.             cookie = vars(cookie)
  1041.         for name, value in cookie.items():
  1042.             yield name, compat_str(value)
  1044.     @classmethod
  1045.     def comparable_cookies(cls, cookies):
  1046.         # Work around cookiejar cookies not being unicode strings
  1047.         return sorted(map(tuple, map(sorted, map(cls.encode_cookie, cookies))))
  1049.     def assertSameCookies(self, c1, c2, msg=None):
  1050.         return self.assertEqual(
  1051.             *map(self.comparable_cookies, (c1, c2)),
  1052.             msg=msg)
  1054.     def assertSameCookieStrings(self, c1, c2, msg=None):
  1055.         return self.assertSameCookies(
  1056.             *map(lambda c: compat_http_cookies_SimpleCookie(c).values(), (c1, c2)),
  1057.             msg=msg)
  1059.     def test_header_cookies(self):
  1061.         ydl = FakeYDL()
  1062.         ydl.report_warning = lambda *_, **__: None
  1064.         def cookie(name, value, version=None, domain='', path='', secure=False, expires=None):
  1065.             return compat_http_cookiejar_Cookie(
  1066.                 version or 0, name, value, None, False,
  1067.                 domain, bool(domain), bool(domain), path, bool(path),
  1068.                 secure, expires, False, None, None, rest={})
  1070.         test_url, test_domain = (t % ('yt.dl',) for t in ('https://%s/test', '.%s'))
  1072.         def test(encoded_cookies, cookies, headers=False, round_trip=None, error_re=None):
  1073.             def _test():
  1074.                 ydl.cookiejar.clear()
  1075.                 ydl._load_cookies(encoded_cookies, autoscope=headers)
  1076.                 if headers:
  1077.                     ydl._apply_header_cookies(test_url)
  1078.                 data = {'url': test_url}
  1079.                 ydl._calc_headers(data)
  1080.                 self.assertSameCookies(
  1081.                     cookies, ydl.cookiejar,
  1082.                     'Extracted cookiejar.Cookie is not the same')
  1083.                 if not headers:
  1084.                     self.assertSameCookieStrings(
  1085.                         data.get('cookies'), round_trip or encoded_cookies,
  1086.                         msg='Cookie is not the same as round trip')
  1087.                 ydl.__dict__['_YoutubeDL__header_cookies'] = []
  1089.             try:
  1090.                 _test()
  1091.             except AssertionError:
  1092.                 raise
  1093.             except Exception as e:
  1094.                 if not error_re:
  1095.                     raise
  1096.                 assertRegexpMatches(self, e.args[0], error_re.join(('.*',) * 2))
  1098.         test('test=value; Domain=' + test_domain, [cookie('test', 'value', domain=test_domain)])
  1099.         test('test=value', [cookie('test', 'value')], error_re='Unscoped cookies are not allowed')
  1100.         test('cookie1=value1; Domain={0}; Path=/test; cookie2=value2; Domain={0}; Path=/'.format(test_domain), [
  1101.             cookie('cookie1', 'value1', domain=test_domain, path='/test'),
  1102.             cookie('cookie2', 'value2', domain=test_domain, path='/')])
  1103.         cookie_kw = compat_kwargs(
  1104.             {'domain': test_domain, 'path': '/test', 'secure': True, 'expires': '9999999999', })
  1105.         test('test=value; Domain={domain}; Path={path}; Secure; Expires={expires}'.format(**cookie_kw), [
  1106.             cookie('test', 'value', **cookie_kw)])
  1107.         test('test="value; "; path=/test; domain=' + test_domain, [
  1108.             cookie('test', 'value; ', domain=test_domain, path='/test')],
  1109.             round_trip='test="value\\073 "; Domain={0}; Path=/test'.format(test_domain))
  1110.         test('name=; Domain=' + test_domain, [cookie('name', '', domain=test_domain)],
  1111.              round_trip='name=""; Domain=' + test_domain)
  1112.         test('test=value', [cookie('test', 'value', domain=test_domain)], headers=True)
  1113.         test('cookie1=value; Domain={0}; cookie2=value'.format(test_domain), [],
  1114.              headers=True, error_re='Invalid syntax')
  1115.         ydl.report_warning = ydl.report_error
  1116.         test('test=value', [], headers=True, error_re='Passing cookies as a header is a potential security risk')
  1118.     def test_infojson_cookies(self):
  1119.         TEST_FILE = 'test_infojson_cookies.info.json'
  1120.         TEST_URL = 'https://example.com/example.mp4'
  1121.         COOKIES = 'a=b; Domain=.example.com; c=d; Domain=.example.com'
  1122.         COOKIE_HEADER = {'Cookie': 'a=b; c=d'}
  1124.         ydl = FakeYDL()
  1125.         ydl.process_info = lambda x: ydl._write_info_json('test', x, TEST_FILE)
  1127.         def make_info(info_header_cookies=False, fmts_header_cookies=False, cookies_field=False):
  1128.             fmt = {'url': TEST_URL}
  1129.             if fmts_header_cookies:
  1130.                 fmt['http_headers'] = COOKIE_HEADER
  1131.             if cookies_field:
  1132.                 fmt['cookies'] = COOKIES
  1133.             return _make_result([fmt], http_headers=COOKIE_HEADER if info_header_cookies else None)
  1135.         def test(initial_info, note):
  1137.             def failure_msg(why):
  1138.                 return ' when '.join((why, note))
  1140.             result = {}
  1141.             result['processed'] = ydl.process_ie_result(initial_info)
  1142.             self.assertTrue(ydl.cookiejar.get_cookies_for_url(TEST_URL),
  1143.                             msg=failure_msg('No cookies set in cookiejar after initial process'))
  1144.             ydl.cookiejar.clear()
  1145.             with open(TEST_FILE) as infojson:
  1146.                 result['loaded'] = ydl.sanitize_info(json.load(infojson), True)
  1147.             result['final'] = ydl.process_ie_result(result['loaded'].copy(), download=False)
  1148.             self.assertTrue(ydl.cookiejar.get_cookies_for_url(TEST_URL),
  1149.                             msg=failure_msg('No cookies set in cookiejar after final process'))
  1150.             ydl.cookiejar.clear()
  1151.             for key in ('processed', 'loaded', 'final'):
  1152.                 info = result[key]
  1153.                 self.assertIsNone(
  1154.                     traverse_obj(info, ((None, ('formats', 0)), 'http_headers', 'Cookie'), casesense=False, get_all=False),
  1155.                     msg=failure_msg('Cookie header not removed in {0} result'.format(key)))
  1156.                 self.assertSameCookieStrings(
  1157.                     traverse_obj(info, ((None, ('formats', 0)), 'cookies'), get_all=False), COOKIES,
  1158.                     msg=failure_msg('No cookies field found in {0} result'.format(key)))
  1160.         test({'url': TEST_URL, 'http_headers': COOKIE_HEADER, 'id': '1', 'title': 'x'}, 'no formats field')
  1161.         test(make_info(info_header_cookies=True), 'info_dict header cokies')
  1162.         test(make_info(fmts_header_cookies=True), 'format header cookies')
  1163.         test(make_info(info_header_cookies=True, fmts_header_cookies=True), 'info_dict and format header cookies')
  1164.         test(make_info(info_header_cookies=True, fmts_header_cookies=True, cookies_field=True), 'all cookies fields')
  1165.         test(make_info(cookies_field=True), 'cookies format field')
  1166.         test({'url': TEST_URL, 'cookies': COOKIES, 'id': '1', 'title': 'x'}, 'info_dict cookies field only')
  1168.         try_rm(TEST_FILE)
  1170.     def test_add_headers_cookie(self):
  1171.         def check_for_cookie_header(result):
  1172.             return traverse_obj(result, ((None, ('formats', 0)), 'http_headers', 'Cookie'), casesense=False, get_all=False)
  1174.         ydl = FakeYDL({'http_headers': {'Cookie': 'a=b'}})
  1175.         ydl._apply_header_cookies(_make_result([])['webpage_url'])  # Scope to input webpage URL: .example.com
  1177.         fmt = {'url': 'https://example.com/video.mp4'}
  1178.         result = ydl.process_ie_result(_make_result([fmt]), download=False)
  1179.         self.assertIsNone(check_for_cookie_header(result), msg='http_headers cookies in result info_dict')
  1180.         self.assertEqual(result.get('cookies'), 'a=b; Domain=.example.com', msg='No cookies were set in cookies field')
  1181.         self.assertIn('a=b', ydl.cookiejar.get_cookie_header(fmt['url']), msg='No cookies were set in cookiejar')
  1183.         fmt = {'url': 'https://wrong.com/video.mp4'}
  1184.         result = ydl.process_ie_result(_make_result([fmt]), download=False)
  1185.         self.assertIsNone(check_for_cookie_header(result), msg='http_headers cookies for wrong domain')
  1186.         self.assertFalse(result.get('cookies'), msg='Cookies set in cookies field for wrong domain')
  1187.         self.assertFalse(ydl.cookiejar.get_cookie_header(fmt['url']), msg='Cookies set in cookiejar for wrong domain')
  1190. if __name__ == '__main__':
  1191.     unittest.main()