From 1a457ed68769880ab7760e0746f0cbbd9ca00487 Mon Sep 17 00:00:00 2001 From: Unit 193 Date: Sat, 28 Sep 2024 20:01:25 -0400 Subject: New upstream version 1.27.5. --- test/test_extractor.py | 19 +++++++++++++++---- test/test_formatter.py | 11 +++++++++++ test/test_results.py | 42 +++++++++++++++++++++++++++++------------- test/test_text.py | 8 ++++---- test/test_util.py | 16 ++++++++++++++++ 5 files changed, 75 insertions(+), 21 deletions(-) (limited to 'test') diff --git a/test/test_extractor.py b/test/test_extractor.py index abf122b..e622fa8 100644 --- a/test/test_extractor.py +++ b/test/test_extractor.py @@ -105,15 +105,23 @@ class TestExtractorModule(unittest.TestCase): def test_categories(self): for result in results.all(): url = result["#url"] - base, cat, sub = result["#category"] + cls = result["#class"] try: - extr = result["#class"].from_url(url) + extr = cls.from_url(url) except ImportError as exc: if exc.name in ("youtube_dl", "yt_dlp"): - print("Skipping '{}' category checks".format(cat)) + print("Skipping '{}' category checks".format(cls.category)) continue raise self.assertTrue(extr, url) + + categories = result.get("#category") + if categories: + base, cat, sub = categories + else: + cat = cls.category + sub = cls.subcategory + base = cls.basecategory self.assertEqual(extr.category, cat, url) self.assertEqual(extr.subcategory, sub, url) self.assertEqual(extr.basecategory, base, url) @@ -243,9 +251,12 @@ class TestExtractorWait(unittest.TestCase): def test_wait_until_datetime(self): extr = extractor.find("generic:https://example.org/") - until = datetime.utcnow() + timedelta(seconds=5) + until = util.datetime_utcnow() + timedelta(seconds=5) until_local = datetime.now() + timedelta(seconds=5) + if not until.microsecond: + until = until.replace(microsecond=until_local.microsecond) + with patch("time.sleep") as sleep, patch.object(extr, "log") as log: extr.wait(until=until) diff --git a/test/test_formatter.py b/test/test_formatter.py index 75324fb..f1d752d 100644 --- a/test/test_formatter.py +++ b/test/test_formatter.py @@ -67,6 +67,9 @@ class TestFormatter(unittest.TestCase): self._run_test("{l!j}", '["a", "b", "c"]') self._run_test("{dt!j}", '"2010-01-01 00:00:00"') self._run_test("{a!g}", "hello-world") + self._run_test("{a!L}", 11) + self._run_test("{l!L}", 3) + self._run_test("{d!L}", 3) with self.assertRaises(KeyError): self._run_test("{a!q}", "hello world") @@ -351,6 +354,14 @@ class TestFormatter(unittest.TestCase): self.assertRegex(out1, r"^\d{4}-\d\d-\d\d \d\d:\d\d:\d\d(\.\d+)?$") self.assertNotEqual(out1, out2) + def test_globals_nul(self): + value = "None" + + self._run_test("{_nul}" , value) + self._run_test("{_nul[key]}" , value) + self._run_test("{z|_nul}" , value) + self._run_test("{z|_nul:%Y%m%s}", value) + def test_literals(self): value = "foo" diff --git a/test/test_results.py b/test/test_results.py index e2c7ca2..aa09f2f 100644 --- a/test/test_results.py +++ b/test/test_results.py @@ -43,7 +43,8 @@ CONFIG = { }, } -AUTH = { + +AUTH_REQUIRED = { "pixiv", "nijie", "horne", @@ -54,7 +55,7 @@ AUTH = { "twitter", } -AUTH_CONFIG = ( +AUTH_KEYS = ( "username", "cookies", "api-key", @@ -91,24 +92,28 @@ class TestExtractorResults(unittest.TestCase): self.assertGreaterEqual(value, range.start, msg=msg) def _run_test(self, result): + base, cat, sub = result_categories(result) result.pop("#comment", None) + result.pop("#category", None) auth = result.pop("#auth", None) - extractor.find(result["#url"]) - extr = result["#class"].from_url(result["#url"]) - if not extr: - raise exception.NoExtractorError() - if len(result) <= 3: + extr_url = extractor.find(result["#url"]) + self.assertTrue(extr_url, "extractor by URL/find") + extr_cls = extr = result["#class"].from_url(result["#url"]) + self.assertTrue(extr_url, "extractor by cls.from_url()") + self.assertIs(extr_url.__class__, extr_cls.__class__) + + if len(result) <= 2: return # only matching if auth is None: - auth = (result["#category"][1] in AUTH) + auth = (cat in AUTH_REQUIRED) elif not auth: # auth explicitly disabled - for key in AUTH_CONFIG: + for key in AUTH_KEYS: config.set((), key, None) - if auth and not any(extr.config(key) for key in AUTH_CONFIG): + if auth and not any(extr.config(key) for key in AUTH_KEYS): return self._skipped.append((result["#url"], "no auth")) if "#options" in result: @@ -411,6 +416,15 @@ def load_test_config(): path, exc.__class__.__name__, exc)) +def result_categories(result): + categories = result.get("#category") + if categories: + return categories + + cls = result["#class"] + return cls.basecategory, cls.category, cls.subcategory + + def generate_tests(): """Dynamically generate extractor unittests""" def _generate_method(result): @@ -437,7 +451,7 @@ def generate_tests(): if category.startswith("+"): basecategory = category[1:].lower() tests = [t for t in results.all() - if t["#category"][0].lower() == basecategory] + if result_categories(t)[0].lower() == basecategory] else: tests = results.category(category) @@ -450,14 +464,16 @@ def generate_tests(): tests = [t for t in tests if "#comment" in t and com in t["#comment"].lower()] else: - tests = [t for t in tests if t["#category"][-1] == subcategory] + tests = [t for t in tests + if result_categories(t)[-1] == subcategory] else: tests = results.all() # add 'test_...' methods enum = collections.defaultdict(int) for result in tests: - name = "{1}_{2}".format(*result["#category"]) + base, cat, sub = result_categories(result) + name = "{}_{}".format(cat, sub) enum[name] += 1 method = _generate_method(result) diff --git a/test/test_text.py b/test/test_text.py index c99729c..084436b 100644 --- a/test/test_text.py +++ b/test/test_text.py @@ -14,7 +14,7 @@ import unittest import datetime sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) -from gallery_dl import text # noqa E402 +from gallery_dl import text, util # noqa E402 INVALID = ((), [], {}, None, 1, 2.3) @@ -414,8 +414,8 @@ class TestText(unittest.TestCase): self.assertEqual(f(value), {}) def test_parse_timestamp(self, f=text.parse_timestamp): - null = datetime.datetime.utcfromtimestamp(0) - value = datetime.datetime.utcfromtimestamp(1555816235) + null = util.datetime_utcfromtimestamp(0) + value = util.datetime_utcfromtimestamp(1555816235) self.assertEqual(f(0) , null) self.assertEqual(f("0") , null) @@ -427,7 +427,7 @@ class TestText(unittest.TestCase): self.assertEqual(f(value, "foo"), "foo") def test_parse_datetime(self, f=text.parse_datetime): - null = datetime.datetime.utcfromtimestamp(0) + null = util.datetime_utcfromtimestamp(0) self.assertEqual(f("1970-01-01T00:00:00+00:00"), null) self.assertEqual(f("1970-01-01T00:00:00+0000") , null) diff --git a/test/test_util.py b/test/test_util.py index fd2ff8b..e2db29b 100644 --- a/test/test_util.py +++ b/test/test_util.py @@ -738,6 +738,22 @@ def hash(value): self.assertEqual(f(datetime.datetime(2010, 1, 1)), "1262304000") self.assertEqual(f(None), "") + def test_datetime_from_timestamp( + self, f=util.datetime_from_timestamp): + self.assertEqual(f(0.0), util.EPOCH) + self.assertEqual(f(1262304000.0), datetime.datetime(2010, 1, 1)) + self.assertEqual(f(1262304000.128000).replace(microsecond=0), + datetime.datetime(2010, 1, 1, 0, 0, 0)) + + def test_datetime_utcfromtimestamp( + self, f=util.datetime_utcfromtimestamp): + self.assertEqual(f(0.0), util.EPOCH) + self.assertEqual(f(1262304000.0), datetime.datetime(2010, 1, 1)) + + def test_datetime_utcnow( + self, f=util.datetime_utcnow): + self.assertIsInstance(f(), datetime.datetime) + def test_universal_none(self): obj = util.NONE -- cgit v1.2.3