New upstream version 1.27.5.upstream/1.27.5

5 files changed, 75 insertions, 21 deletions

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