You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

220 lines
8.3 KiB

11 years ago
11 years ago
11 years ago
11 years ago
11 years ago
11 years ago
11 years ago
10 years ago
11 years ago
11 years ago
11 years ago
10 years ago
10 years ago
  1. from __future__ import unicode_literals
  2. import errno
  3. import io
  4. import hashlib
  5. import json
  6. import os.path
  7. import re
  8. import types
  9. import sys
  10. import youtube_dl.extractor
  11. from youtube_dl import YoutubeDL
  12. from youtube_dl.utils import (
  13. compat_str,
  14. preferredencoding,
  15. write_string,
  16. )
  17. def get_params(override=None):
  18. PARAMETERS_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)),
  19. "parameters.json")
  20. with io.open(PARAMETERS_FILE, encoding='utf-8') as pf:
  21. parameters = json.load(pf)
  22. if override:
  23. parameters.update(override)
  24. return parameters
  25. def try_rm(filename):
  26. """ Remove a file if it exists """
  27. try:
  28. os.remove(filename)
  29. except OSError as ose:
  30. if ose.errno != errno.ENOENT:
  31. raise
  32. def report_warning(message):
  33. '''
  34. Print the message to stderr, it will be prefixed with 'WARNING:'
  35. If stderr is a tty file the 'WARNING:' will be colored
  36. '''
  37. if sys.stderr.isatty() and os.name != 'nt':
  38. _msg_header = '\033[0;33mWARNING:\033[0m'
  39. else:
  40. _msg_header = 'WARNING:'
  41. output = '%s %s\n' % (_msg_header, message)
  42. if 'b' in getattr(sys.stderr, 'mode', '') or sys.version_info[0] < 3:
  43. output = output.encode(preferredencoding())
  44. sys.stderr.write(output)
  45. class FakeYDL(YoutubeDL):
  46. def __init__(self, override=None):
  47. # Different instances of the downloader can't share the same dictionary
  48. # some test set the "sublang" parameter, which would break the md5 checks.
  49. params = get_params(override=override)
  50. super(FakeYDL, self).__init__(params, auto_init=False)
  51. self.result = []
  52. def to_screen(self, s, skip_eol=None):
  53. print(s)
  54. def trouble(self, s, tb=None):
  55. raise Exception(s)
  56. def download(self, x):
  57. self.result.append(x)
  58. def expect_warning(self, regex):
  59. # Silence an expected warning matching a regex
  60. old_report_warning = self.report_warning
  61. def report_warning(self, message):
  62. if re.match(regex, message):
  63. return
  64. old_report_warning(message)
  65. self.report_warning = types.MethodType(report_warning, self)
  66. def gettestcases(include_onlymatching=False):
  67. for ie in youtube_dl.extractor.gen_extractors():
  68. for tc in ie.get_testcases(include_onlymatching):
  69. yield tc
  70. md5 = lambda s: hashlib.md5(s.encode('utf-8')).hexdigest()
  71. def expect_info_dict(self, got_dict, expected_dict):
  72. for info_field, expected in expected_dict.items():
  73. if isinstance(expected, compat_str) and expected.startswith('re:'):
  74. got = got_dict.get(info_field)
  75. match_str = expected[len('re:'):]
  76. match_rex = re.compile(match_str)
  77. self.assertTrue(
  78. isinstance(got, compat_str),
  79. 'Expected a %s object, but got %s for field %s' % (
  80. compat_str.__name__, type(got).__name__, info_field))
  81. self.assertTrue(
  82. match_rex.match(got),
  83. 'field %s (value: %r) should match %r' % (info_field, got, match_str))
  84. elif isinstance(expected, compat_str) and expected.startswith('startswith:'):
  85. got = got_dict.get(info_field)
  86. start_str = expected[len('startswith:'):]
  87. self.assertTrue(
  88. isinstance(got, compat_str),
  89. 'Expected a %s object, but got %s for field %s' % (
  90. compat_str.__name__, type(got).__name__, info_field))
  91. self.assertTrue(
  92. got.startswith(start_str),
  93. 'field %s (value: %r) should start with %r' % (info_field, got, start_str))
  94. elif isinstance(expected, compat_str) and expected.startswith('contains:'):
  95. got = got_dict.get(info_field)
  96. contains_str = expected[len('contains:'):]
  97. self.assertTrue(
  98. isinstance(got, compat_str),
  99. 'Expected a %s object, but got %s for field %s' % (
  100. compat_str.__name__, type(got).__name__, info_field))
  101. self.assertTrue(
  102. contains_str in got,
  103. 'field %s (value: %r) should contain %r' % (info_field, got, contains_str))
  104. elif isinstance(expected, type):
  105. got = got_dict.get(info_field)
  106. self.assertTrue(isinstance(got, expected),
  107. 'Expected type %r for field %s, but got value %r of type %r' % (expected, info_field, got, type(got)))
  108. else:
  109. if isinstance(expected, compat_str) and expected.startswith('md5:'):
  110. got = 'md5:' + md5(got_dict.get(info_field))
  111. elif isinstance(expected, compat_str) and expected.startswith('mincount:'):
  112. got = got_dict.get(info_field)
  113. self.assertTrue(
  114. isinstance(got, list),
  115. 'Expected field %s to be a list, but it is of type %s' % (
  116. info_field, type(got).__name__))
  117. expected_num = int(expected.partition(':')[2])
  118. assertGreaterEqual(
  119. self, len(got), expected_num,
  120. 'Expected %d items in field %s, but only got %d' % (
  121. expected_num, info_field, len(got)
  122. )
  123. )
  124. continue
  125. else:
  126. got = got_dict.get(info_field)
  127. self.assertEqual(expected, got,
  128. 'invalid value for field %s, expected %r, got %r' % (info_field, expected, got))
  129. # Check for the presence of mandatory fields
  130. if got_dict.get('_type') not in ('playlist', 'multi_video'):
  131. for key in ('id', 'url', 'title', 'ext'):
  132. self.assertTrue(got_dict.get(key), 'Missing mandatory field %s' % key)
  133. # Check for mandatory fields that are automatically set by YoutubeDL
  134. for key in ['webpage_url', 'extractor', 'extractor_key']:
  135. self.assertTrue(got_dict.get(key), 'Missing field: %s' % key)
  136. # Are checkable fields missing from the test case definition?
  137. test_info_dict = dict((key, value if not isinstance(value, compat_str) or len(value) < 250 else 'md5:' + md5(value))
  138. for key, value in got_dict.items()
  139. if value and key in ('id', 'title', 'description', 'uploader', 'upload_date', 'timestamp', 'uploader_id', 'location'))
  140. missing_keys = set(test_info_dict.keys()) - set(expected_dict.keys())
  141. if missing_keys:
  142. def _repr(v):
  143. if isinstance(v, compat_str):
  144. return "'%s'" % v.replace('\\', '\\\\').replace("'", "\\'").replace('\n', '\\n')
  145. else:
  146. return repr(v)
  147. info_dict_str = ''
  148. if len(missing_keys) != len(expected_dict):
  149. info_dict_str += ''.join(
  150. ' %s: %s,\n' % (_repr(k), _repr(v))
  151. for k, v in test_info_dict.items() if k not in missing_keys)
  152. if info_dict_str:
  153. info_dict_str += '\n'
  154. info_dict_str += ''.join(
  155. ' %s: %s,\n' % (_repr(k), _repr(test_info_dict[k]))
  156. for k in missing_keys)
  157. write_string(
  158. '\n\'info_dict\': {\n' + info_dict_str + '},\n', out=sys.stderr)
  159. self.assertFalse(
  160. missing_keys,
  161. 'Missing keys in test definition: %s' % (
  162. ', '.join(sorted(missing_keys))))
  163. def assertRegexpMatches(self, text, regexp, msg=None):
  164. if hasattr(self, 'assertRegexp'):
  165. return self.assertRegexp(text, regexp, msg)
  166. else:
  167. m = re.match(regexp, text)
  168. if not m:
  169. note = 'Regexp didn\'t match: %r not found' % (regexp)
  170. if len(text) < 1000:
  171. note += ' in %r' % text
  172. if msg is None:
  173. msg = note
  174. else:
  175. msg = note + ', ' + msg
  176. self.assertTrue(m, msg)
  177. def assertGreaterEqual(self, got, expected, msg=None):
  178. if not (got >= expected):
  179. if msg is None:
  180. msg = '%r not greater than or equal to %r' % (got, expected)
  181. self.assertTrue(got >= expected, msg)
  182. def expect_warnings(ydl, warnings_re):
  183. real_warning = ydl.report_warning
  184. def _report_warning(w):
  185. if not any(re.search(w_re, w) for w_re in warnings_re):
  186. real_warning(w)
  187. ydl.report_warning = _report_warning