Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
mikf
GitHub Repository: mikf/gallery-dl
 Path: blob/master/test/test_config.py
5457 views
1
#!/usr/bin/env python3

2
# -*- coding: utf-8 -*-

3


4
# Copyright 2015-2025 Mike Fährmann

5
#

6
# This program is free software; you can redistribute it and/or modify

7
# it under the terms of the GNU General Public License version 2 as

8
# published by the Free Software Foundation.

9


10
import os

11
import sys

12
import unittest

13


14
import tempfile

15


16
ROOTDIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

17
sys.path.insert(0, ROOTDIR)

18
from gallery_dl import config, util  # noqa E402

19


20


21
class TestConfig(unittest.TestCase):

22


23
    def setUp(self):

24
        config.set(()        , "a", 1)

25
        config.set(("b",)    , "a", 2)

26
        config.set(("b", "b"), "a", 3)

27
        config.set(("b",)    , "c", "text")

28
        config.set(("b", "b"), "c", [8, 9])

29


30
    def tearDown(self):

31
        config.clear()

32


33
    def test_get(self):

34
        self.assertEqual(config.get(()        , "a")   , 1)

35
        self.assertEqual(config.get(("b",)    , "a")   , 2)

36
        self.assertEqual(config.get(("b", "b"), "a")   , 3)

37


38
        self.assertEqual(config.get(()        , "c")   , None)

39
        self.assertEqual(config.get(("b",)    , "c")   , "text")

40
        self.assertEqual(config.get(("b", "b"), "c")   , [8, 9])

41


42
        self.assertEqual(config.get(("a",)    , "g")   , None)

43
        self.assertEqual(config.get(("a", "a"), "g")   , None)

44
        self.assertEqual(config.get(("e", "f"), "g")   , None)

45
        self.assertEqual(config.get(("e", "f"), "g", 4), 4)

46


47
    def test_interpolate(self):

48
        self.assertEqual(config.interpolate(()        , "a"), 1)

49
        self.assertEqual(config.interpolate(("b",)    , "a"), 1)

50
        self.assertEqual(config.interpolate(("b", "b"), "a"), 1)

51


52
        self.assertEqual(config.interpolate(()        , "c"), None)

53
        self.assertEqual(config.interpolate(("b",)    , "c"), "text")

54
        self.assertEqual(config.interpolate(("b", "b"), "c"), [8, 9])

55


56
        self.assertEqual(config.interpolate(("a",)    , "g")   , None)

57
        self.assertEqual(config.interpolate(("a", "a"), "g")   , None)

58
        self.assertEqual(config.interpolate(("e", "f"), "g")   , None)

59
        self.assertEqual(config.interpolate(("e", "f"), "g", 4), 4)

60


61
        self.assertEqual(config.interpolate(("b",), "d", 1) , 1)

62
        self.assertEqual(config.interpolate(("d",), "d", 1) , 1)

63
        config.set(()    , "d", 2)

64
        self.assertEqual(config.interpolate(("b",), "d", 1) , 2)

65
        self.assertEqual(config.interpolate(("d",), "d", 1) , 2)

66
        config.set(("b",), "d", 3)

67
        self.assertEqual(config.interpolate(("b",), "d", 1) , 2)

68
        self.assertEqual(config.interpolate(("d",), "d", 1) , 2)

69


70
    def test_interpolate_common(self):

71


72
        def lookup():

73
            return config.interpolate_common(

74
                ("Z1", "Z2"), (

75
                    ("A1", "A2"),

76
                    ("B1",),

77
                    ("C1", "C2", "C3"),

78
                ), "KEY", "DEFAULT",

79
            )

80


81
        def test(path, value, expected=None):

82
            config.set(path, "KEY", value)

83
            self.assertEqual(lookup(), expected or value)

84


85
        self.assertEqual(lookup(), "DEFAULT")

86
        test(("Z1",), 1)

87
        test(("Z1", "Z2"), 2)

88
        test(("Z1", "Z2", "C1"), 3)

89
        test(("Z1", "Z2", "C1", "C2"), 4)

90
        test(("Z1", "Z2", "C1", "C2", "C3"), 5)

91
        test(("Z1", "Z2", "B1"), 6)

92
        test(("Z1", "Z2", "A1"), 7)

93
        test(("Z1", "Z2", "A1", "A2"), 8)

94
        test(("Z1", "A1", "A2"), 999, 8)

95
        test(("Z1", "Z2", "A1", "A2", "A3"), 999, 8)

96
        test((), 9)

97


98
    def test_accumulate(self):

99
        self.assertEqual(config.accumulate((), "l"), [])

100


101
        config.set(()        , "l", [5, 6])

102
        config.set(("c",)    , "l", [3, 4])

103
        config.set(("c", "c"), "l", [1, 2])

104
        self.assertEqual(

105
            config.accumulate((), "l")        , [5, 6])

106
        self.assertEqual(

107
            config.accumulate(("c",), "l")    , [3, 4, 5, 6])

108
        self.assertEqual(

109
            config.accumulate(("c", "c"), "l"), [1, 2, 3, 4, 5, 6])

110


111
        config.set(("c",), "l", None)

112
        config.unset(("c", "c"), "l")

113
        self.assertEqual(

114
            config.accumulate((), "l")        , [5, 6])

115
        self.assertEqual(

116
            config.accumulate(("c",), "l")    , [5, 6])

117
        self.assertEqual(

118
            config.accumulate(("c", "c"), "l"), [5, 6])

119


120
        config.set(()        , "l", 4)

121
        config.set(("c",)    , "l", [2, 3])

122
        config.set(("c", "c"), "l", 1)

123
        self.assertEqual(

124
            config.accumulate((), "l")        , [4])

125
        self.assertEqual(

126
            config.accumulate(("c",), "l")    , [2, 3, 4])

127
        self.assertEqual(

128
            config.accumulate(("c", "c"), "l"), [1, 2, 3, 4])

129


130
        config.set(("c",), "l", None)

131
        self.assertEqual(

132
            config.accumulate((), "l")        , [4])

133
        self.assertEqual(

134
            config.accumulate(("c",), "l")    , [4])

135
        self.assertEqual(

136
            config.accumulate(("c", "c"), "l"), [1, 4])

137


138
    def test_set(self):

139
        config.set(()        , "c", [1, 2, 3])

140
        config.set(("b",)    , "c", [1, 2, 3])

141
        config.set(("e", "f"), "g", value=234)

142
        self.assertEqual(config.get(()        , "c"), [1, 2, 3])

143
        self.assertEqual(config.get(("b",)    , "c"), [1, 2, 3])

144
        self.assertEqual(config.get(("e", "f"), "g"), 234)

145


146
    def test_setdefault(self):

147
        config.setdefault(()        , "c", [1, 2, 3])

148
        config.setdefault(("b",)    , "c", [1, 2, 3])

149
        config.setdefault(("e", "f"), "g", value=234)

150
        self.assertEqual(config.get(()        , "c"), [1, 2, 3])

151
        self.assertEqual(config.get(("b",)    , "c"), "text")

152
        self.assertEqual(config.get(("e", "f"), "g"), 234)

153


154
    def test_unset(self):

155
        config.unset(()    , "a")

156
        config.unset(("b",), "c")

157
        config.unset(("a",), "d")

158
        config.unset(("b",), "d")

159
        config.unset(("c",), "d")

160
        self.assertEqual(config.get(()    , "a"), None)

161
        self.assertEqual(config.get(("b",), "a"), 2)

162
        self.assertEqual(config.get(("b",), "c"), None)

163
        self.assertEqual(config.get(("a",), "d"), None)

164
        self.assertEqual(config.get(("b",), "d"), None)

165
        self.assertEqual(config.get(("c",), "d"), None)

166


167
    def test_apply(self):

168
        options = (

169
            (("b",)    , "c", [1, 2, 3]),

170
            (("e", "f"), "g", 234),

171
            (("e", "f"), "g", 234),

172
        )

173


174
        self.assertEqual(config.get(("b",)    , "c"), "text")

175
        self.assertEqual(config.get(("e", "f"), "g"), None)

176


177
        with config.apply(options):

178
            self.assertEqual(config.get(("b",)    , "c"), [1, 2, 3])

179
            self.assertEqual(config.get(("e", "f"), "g"), 234)

180


181
        self.assertEqual(config.get(("b",)    , "c"), "text")

182
        self.assertEqual(config.get(("e", "f"), "g"), None)

183


184
    def test_load(self):

185
        with tempfile.TemporaryDirectory() as base:

186
            path1 = os.path.join(base, "cfg1")

187
            with open(path1, "w") as fp:

188
                fp.write('{"a": 1, "b": {"a": 2, "c": "text"}}')

189


190
            path2 = os.path.join(base, "cfg2")

191
            with open(path2, "w") as fp:

192
                fp.write('{"a": 7, "b": {"a": 8, "e": "foo"}}')

193


194
            config.clear()

195
            config.load((path1,))

196
            self.assertEqual(config.get(()    , "a"), 1)

197
            self.assertEqual(config.get(("b",), "a"), 2)

198
            self.assertEqual(config.get(("b",), "c"), "text")

199


200
            config.load((path2,))

201
            self.assertEqual(config.get(()    , "a"), 7)

202
            self.assertEqual(config.get(("b",), "a"), 8)

203
            self.assertEqual(config.get(("b",), "c"), "text")

204
            self.assertEqual(config.get(("b",), "e"), "foo")

205


206
            config.clear()

207
            config.load((path1, path2))

208
            self.assertEqual(config.get(()    , "a"), 7)

209
            self.assertEqual(config.get(("b",), "a"), 8)

210
            self.assertEqual(config.get(("b",), "c"), "text")

211
            self.assertEqual(config.get(("b",), "e"), "foo")

212


213


214
class TestConfigFiles(unittest.TestCase):

215


216
    def test_default_config(self):

217
        cfg = self._load("gallery-dl.conf")

218
        self.assertIsInstance(cfg, dict)

219
        self.assertTrue(cfg)

220


221
    def test_example_config(self):

222
        cfg = self._load("gallery-dl-example.conf")

223
        self.assertIsInstance(cfg, dict)

224
        self.assertTrue(cfg)

225


226
    def _load(self, name):

227
        path = os.path.join(ROOTDIR, "docs", name)

228
        try:

229
            with open(path) as fp:

230
                return util.json_loads(fp.read())

231
        except FileNotFoundError:

232
            raise unittest.SkipTest(f"{path} not available")

233


234


235
if __name__ == "__main__":

236
    unittest.main()

237


238