New upstream version 1.30.2.upstream/1.30.2

1 files changed, 187 insertions, 47 deletions

diff --git a/test/test_util.py b/test/test_util.py
index 27f78ec..00e8c4b 100644
--- a/test/test_util.py
+++ b/test/test_util.py
@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-# Copyright 2015-2023 Mike Fährmann
+# Copyright 2015-2025 Mike Fährmann
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as
@@ -10,6 +10,7 @@
 import os
 import sys
 import unittest
+from unittest.mock import patch
 
 import io
 import time
@@ -27,11 +28,18 @@ from gallery_dl import util, text, exception  # noqa E402
 
 class TestRange(unittest.TestCase):
 
-    def test_parse_empty(self, f=util.RangePredicate._parse):
+    def setUp(self):
+        self.predicate = util.RangePredicate("")
+
+    def test_parse_empty(self):
+        f = self.predicate._parse
+
         self.assertEqual(f(""), [])
         self.assertEqual(f([]), [])
 
-    def test_parse_digit(self, f=util.RangePredicate._parse):
+    def test_parse_digit(self):
+        f = self.predicate._parse
+
         self.assertEqual(f("2"), [range(2, 3)])
 
         self.assertEqual(
@@ -41,7 +49,9 @@ class TestRange(unittest.TestCase):
              range(4, 5)],
         )
 
-    def test_parse_range(self, f=util.RangePredicate._parse):
+    def test_parse_range(self):
+        f = self.predicate._parse
+
         self.assertEqual(f("1-2"), [range(1, 3)])
         self.assertEqual(f("2-"), [range(2, sys.maxsize)])
         self.assertEqual(f("-3"), [range(1, 4)])
@@ -61,7 +71,9 @@ class TestRange(unittest.TestCase):
              range(2, 7)],
         )
 
-    def test_parse_slice(self, f=util.RangePredicate._parse):
+    def test_parse_slice(self):
+        f = self.predicate._parse
+
         self.assertEqual(f("2:4")  , [range(2, 4)])
         self.assertEqual(f("3::")  , [range(3, sys.maxsize)])
         self.assertEqual(f(":4:")  , [range(1, 4)])
@@ -149,6 +161,10 @@ class TestPredicate(unittest.TestCase):
 
         self.assertFalse(pred(url, {"a": 2}))
 
+        pred = util.FilterPredicate("re.search(r'.+', url)")
+        self.assertTrue(pred(url, {"url": "https://example.org/"}))
+        self.assertFalse(pred(url, {"url": ""}))
+
     def test_build_predicate(self):
         pred = util.build_predicate([])
         self.assertIsInstance(pred, type(lambda: True))
@@ -390,6 +406,89 @@ def hash(value):
         self.assertEqual(expr(value), result)
 
 
+class TestDatetime(unittest.TestCase):
+
+    def test_to_datetime(self, f=util.to_datetime):
+
+        def _assert(value, expected):
+            result = f(value)
+            self.assertIsInstance(result, datetime.datetime)
+            self.assertEqual(result, expected, msg=repr(value))
+
+        dt = datetime.datetime(2010, 1, 1)
+        self.assertIs(f(dt), dt)
+
+        _assert(dt            , dt)
+        _assert(1262304000    , dt)
+        _assert(1262304000.0  , dt)
+        _assert(1262304000.123, dt)
+        _assert("1262304000"  , dt)
+
+        _assert("2010-01-01"                      , dt)
+        _assert("2010-01-01 00:00:00"             , dt)
+        _assert("2010-01-01T00:00:00"             , dt)
+        _assert("2010-01-01T00:00:00.123456"      , dt)
+        _assert("2009-12-31T19:00:00-05:00"       , dt)
+        _assert("2009-12-31T19:00:00.123456-05:00", dt)
+        _assert("2010-01-01T00:00:00Z"            , dt)
+        _assert("2010-01-01T00:00:00.123456Z"     , dt)
+
+        _assert(0    , util.EPOCH)
+        _assert(""   , util.EPOCH)
+        _assert("foo", util.EPOCH)
+        _assert(None , util.EPOCH)
+        _assert(()   , util.EPOCH)
+        _assert([]   , util.EPOCH)
+        _assert({}   , util.EPOCH)
+        _assert((1, 2, 3), util.EPOCH)
+
+    @unittest.skipIf(sys.hexversion < 0x30b0000,
+                     "extended fromisoformat timezones")
+    def test_to_datetime_tz(self, f=util.to_datetime):
+
+        def _assert(value, expected):
+            result = f(value)
+            self.assertIsInstance(result, datetime.datetime)
+            self.assertEqual(result, expected, msg=repr(value))
+
+        dt = datetime.datetime(2010, 1, 1)
+
+        _assert("2009-12-31T19:00:00-05"          , dt)
+        _assert("2009-12-31T19:00:00-0500"        , dt)
+        _assert("2009-12-31T19:00:00.123456-05"   , dt)
+        _assert("2009-12-31T19:00:00.123456-0500" , dt)
+
+    def test_datetime_to_timestamp(self, f=util.datetime_to_timestamp):
+        self.assertEqual(f(util.EPOCH), 0.0)
+        self.assertEqual(f(datetime.datetime(2010, 1, 1)), 1262304000.0)
+        self.assertEqual(f(datetime.datetime(2010, 1, 1, 0, 0, 0, 128000)),
+                         1262304000.128000)
+        with self.assertRaises(TypeError):
+            f(None)
+
+    def test_datetime_to_timestamp_string(
+            self, f=util.datetime_to_timestamp_string):
+        self.assertEqual(f(util.EPOCH), "0")
+        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)
+
+
 class TestOther(unittest.TestCase):
 
     def test_bencode(self):
@@ -492,6 +591,7 @@ class TestOther(unittest.TestCase):
 
     def test_noop(self):
         self.assertEqual(util.noop(), None)
+        self.assertEqual(util.noop(...), None)
 
     def test_md5(self):
         self.assertEqual(util.md5(b""),
@@ -552,17 +652,21 @@ value = 123
         self.assertEqual(module.value, 123)
         self.assertIs(module.datetime, datetime)
 
-    def test_build_duration_func(self, f=util.build_duration_func):
+    def test_build_selection_func(self, f=util.build_selection_func):
 
-        def test_single(df, v):
+        def test_single(df, v, type=None):
             for _ in range(10):
                 self.assertEqual(df(), v)
+                if type is not None:
+                    self.assertIsInstance(df(), type)
 
-        def test_range(df, lower, upper):
+        def test_range(df, lower, upper, type=None):
             for __ in range(10):
                 v = df()
                 self.assertGreaterEqual(v, lower)
                 self.assertLessEqual(v, upper)
+                if type is not None:
+                    self.assertIsInstance(v, type)
 
         for v in (0, 0.0, "", None, (), []):
             self.assertIsNone(f(v))
@@ -570,16 +674,24 @@ value = 123
         for v in (0, 0.0, "", None, (), []):
             test_single(f(v, 1.0), 1.0)
 
-        test_single(f(3), 3)
-        test_single(f(3.0), 3.0)
-        test_single(f("3"), 3)
-        test_single(f("3.0-"), 3)
-        test_single(f("  3  -"), 3)
+        test_single(f(3)       , 3  , float)
+        test_single(f(3.0)     , 3.0, float)
+        test_single(f("3")     , 3  , float)
+        test_single(f("3.0-")  , 3  , float)
+        test_single(f("  3  -"), 3  , float)
 
-        test_range(f((2, 4)), 2, 4)
-        test_range(f([2, 4]), 2, 4)
-        test_range(f("2-4"), 2, 4)
-        test_range(f("  2.0  - 4 "), 2, 4)
+        test_range(f((2, 4))       , 2, 4, float)
+        test_range(f([2.0, 4.0])   , 2, 4, float)
+        test_range(f("2-4")        , 2, 4, float)
+        test_range(f("  2.0  - 4 "), 2, 4, float)
+
+        pb = text.parse_bytes
+        test_single(f("3", 0, pb)     , 3, int)
+        test_single(f("3.0-", 0, pb)  , 3, int)
+        test_single(f("  3  -", 0, pb), 3, int)
+
+        test_range(f("2k-4k", 0, pb)        , 2048, 4096, int)
+        test_range(f("  2.0k  - 4k ", 0, pb), 2048, 4096, int)
 
     def test_extractor_filter(self):
         # empty
@@ -765,40 +877,16 @@ value = 123
         self.assertEqual(f(["a", "b", "c"]), "a, b, c")
         self.assertEqual(f([1, 2, 3]), "1, 2, 3")
 
-    def test_datetime_to_timestamp(self, f=util.datetime_to_timestamp):
-        self.assertEqual(f(util.EPOCH), 0.0)
-        self.assertEqual(f(datetime.datetime(2010, 1, 1)), 1262304000.0)
-        self.assertEqual(f(datetime.datetime(2010, 1, 1, 0, 0, 0, 128000)),
-                         1262304000.128000)
-        with self.assertRaises(TypeError):
-            f(None)
-
-    def test_datetime_to_timestamp_string(
-            self, f=util.datetime_to_timestamp_string):
-        self.assertEqual(f(util.EPOCH), "0")
-        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
 
         self.assertFalse(obj)
+        self.assertEqual(obj, obj)
+        self.assertEqual(obj, None)
+        self.assertNotEqual(obj, False)
+        self.assertNotEqual(obj, 0)
+        self.assertNotEqual(obj, "")
+
         self.assertEqual(len(obj), 0)
         self.assertEqual(int(obj), 0)
         self.assertEqual(hash(obj), 0)
@@ -873,6 +961,26 @@ value = 123
             i += 1
         self.assertEqual(i, 0)
 
+    def test_HTTPBasicAuth(self, f=util.HTTPBasicAuth):
+        class Request:
+            headers = {}
+        request = Request()
+
+        auth = f("", "")
+        auth(request)
+        self.assertEqual(request.headers["Authorization"],
+                         b"Basic Og==")
+
+        f("foo", "bar")(request)
+        self.assertEqual(request.headers["Authorization"],
+                         b"Basic Zm9vOmJhcg==")
+
+        f("ewsxcvbhnjtr",
+          "RVXQ4i9Ju5ypi86VGJ8MqhDYpDKluS0sxiSRBAG7ymB3Imok")(request)
+        self.assertEqual(request.headers["Authorization"],
+                         b"Basic ZXdzeGN2YmhuanRyOlJWWFE0aTlKdTV5cGk4NlZHSjhNc"
+                         b"WhEWXBES2x1UzBzeGlTUkJBRzd5bUIzSW1vaw==")
+
     def test_module_proxy(self):
         proxy = util.ModuleProxy()
 
@@ -887,6 +995,16 @@ value = 123
         self.assertIs(proxy["abc.def.ghi"], util.NONE)
         self.assertIs(proxy["os.path2"], util.NONE)
 
+    def test_lazy_prompt(self):
+        prompt = util.LazyPrompt()
+
+        with patch("getpass.getpass") as p:
+            p.return_value = "***"
+            result = str(prompt)
+
+        self.assertEqual(result, "***")
+        p.assert_called_once_with()
+
     def test_null_context(self):
         with util.NullContext():
             pass
@@ -901,6 +1019,28 @@ value = 123
         except ValueError as exc:
             self.assertIs(exc, exc_orig)
 
+    def test_null_response(self):
+        response = util.NullResponse("https://example.org")
+
+        self.assertEqual(response.url, "https://example.org")
+        self.assertEqual(response.status_code, 900)
+        self.assertEqual(response.reason, "")
+        self.assertEqual(response.text, "")
+        self.assertEqual(response.content, b"")
+        self.assertEqual(response.json(), {})
+
+        self.assertFalse(response.ok)
+        self.assertFalse(response.is_redirect)
+        self.assertFalse(response.is_permanent_redirect)
+        self.assertFalse(response.history)
+
+        self.assertEqual(response.encoding, "utf-8")
+        self.assertEqual(response.apparent_encoding, "utf-8")
+        self.assertEqual(response.cookies.get("foo"), None)
+        self.assertEqual(response.headers.get("foo"), None)
+        self.assertEqual(response.links.get("next"), None)
+        self.assertEqual(response.close(), None)
+
 
 class TestExtractor():
     category = "test_category"