CoCalc -- test_config.py

GitHub Repository: singlestore-labs/singlestoredb-python
Path: blob/main/singlestoredb/tests/test_config.py
⁴⁶⁹ views
1
#!/usr/bin/env python
2
# type: ignore
3
# encoding: utf-8
4
#
5
# Copyright SAS Institute
6
#
7
#  Licensed under the Apache License, Version 2.0 (the License);
8
#  you may not use this file except in compliance with the License.
9
#  You may obtain a copy of the License at
10
#
11
#      http://www.apache.org/licenses/LICENSE-2.0
12
#
13
#  Unless required by applicable law or agreed to in writing, software
14
#  distributed under the License is distributed on an "AS IS" BASIS,
15
#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16
#  See the License for the specific language governing permissions and
17
#  limitations under the License.
18
#
19
#  This file originally copied from https://github.com/sassoftware/python-swat
20
#
21
import unittest
22

23
from singlestoredb.config import check_bool
24
from singlestoredb.config import check_float
25
from singlestoredb.config import check_int
26
from singlestoredb.config import check_str
27
from singlestoredb.config import check_url
28
from singlestoredb.config import describe_option
29
from singlestoredb.config import get_default
30
from singlestoredb.config import get_option
31
from singlestoredb.config import get_suboptions
32
from singlestoredb.config import options
33
from singlestoredb.config import reset_option
34
from singlestoredb.config import set_option
35

36

37
class TestConfig(unittest.TestCase):
38

39
    def setUp(self):
40
        reset_option()
41

42
    def tearDown(self):
43
        reset_option()
44

45
    def test_basic(self):
46
        self.assertEqual(get_option('local_infile'), False)
47

48
        set_option('local_infile', True)
49

50
        self.assertEqual(get_option('local_infile'), True)
51

52
        with self.assertRaises(ValueError):
53
            options.local_infile = 'foo'
54

55
        options.local_infile = False
56
        self.assertEqual(options.local_infile, False)
57

58
        with self.assertRaises(ValueError):
59
            options.local_infile = 10
60

61
        self.assertEqual(options.local_infile, False)
62

63
        self.assertEqual(type(options.results), type(options))
64

65
        options.local_infile = False
66

67
        reset_option('local_infile')
68

69
        self.assertEqual(options.local_infile, False)
70

71
        with self.assertRaises(KeyError):
72
            reset_option('results.foo')
73

74
        with self.assertRaises(TypeError):
75
            reset_option('results')
76

77
    def test_shortcut_options(self):
78
        asize = get_option('results.arraysize')
79
        token = get_option('management.token')
80

81
        self.assertEqual(get_option('arraysize'), asize)
82
        self.assertEqual(options.arraysize, asize)
83

84
        options.arraysize = 20
85

86
        self.assertEqual(get_option('results.arraysize'), 20)
87
        self.assertEqual(options.results.arraysize, 20)
88
        self.assertEqual(options.arraysize, 20)
89

90
        self.assertEqual(get_option('token'), token)
91
        self.assertEqual(get_option('management.token'), token)
92
        self.assertEqual(options.token, token)
93

94
        options.token = 'Foo'
95

96
        self.assertEqual(get_option('token'), 'Foo')
97
        self.assertEqual(get_option('management.token'), 'Foo')
98
        self.assertEqual(options.token, 'Foo')
99

100
        reset_option('token')
101

102
        self.assertEqual(get_option('token'), token)
103
        self.assertEqual(get_option('management.token'), token)
104
        self.assertEqual(options.token, token)
105

106
    def test_missing_options(self):
107
        with self.assertRaises(KeyError):
108
            set_option('results.foo', 10)
109

110
        with self.assertRaises(KeyError):
111
            options.results.foo = 10
112

113
        with self.assertRaises(KeyError):
114
            get_option('results.foo')
115

116
        with self.assertRaises(KeyError):
117
            print(options.results.foo)
118

119
        # You can not access a midpoint in the hierarchy with (s|g)et_option
120
        with self.assertRaises(TypeError):
121
            set_option('results', 10)
122

123
        with self.assertRaises(TypeError):
124
            get_option('results')
125

126
    def test_errors(self):
127
        with self.assertRaises(ValueError):
128
            set_option('credential_type', 'foo')
129

130
    def test_doc(self):
131
        out = describe_option('results.arraysize', 'local_infile', _print_desc=False)
132
        for line in out.split('\n'):
133
            if not line or line.startswith(' '):
134
                continue
135
            self.assertRegex(line, r'^(results\.arraysize|local_infile)')
136

137
        # Displays entire option hierarchy
138
        out = describe_option('management', _print_desc=False)
139
        for line in out.split('\n'):
140
            if not line or line.startswith(' '):
141
                continue
142
            self.assertRegex(line, r'^management\.')
143

144
        with self.assertRaises(KeyError):
145
            describe_option('management.foo')
146

147
        out = describe_option(_print_desc=False)
148
        self.assertRegex(out, r'\bmanagement\.token :')
149
        self.assertRegex(out, r'\bhost :')
150
        self.assertRegex(out, r'\bport :')
151
        self.assertRegex(out, r'\buser :')
152
        self.assertRegex(out, r'\bpassword :')
153
        self.assertRegex(out, r'\bcharset :')
154

155
    def test_suboptions(self):
156
        self.assertEqual(
157
            list(sorted(get_suboptions('results').keys())),
158
            ['arraysize', 'type'],
159
        )
160

161
        with self.assertRaises(KeyError):
162
            get_suboptions('results.foo')
163

164
        # This is an option, not a level in the hierarchy
165
        with self.assertRaises(TypeError):
166
            get_suboptions('results.arraysize')
167

168
    def test_get_default(self):
169
        self.assertEqual(get_default('results.arraysize'), 1)
170

171
        with self.assertRaises(KeyError):
172
            get_default('results.foo')
173

174
        # This is a level in the hierarchy, not an option
175
        with self.assertRaises(TypeError):
176
            get_default('results')
177

178
    def test_check_int(self):
179
        self.assertEqual(check_int(10), 10)
180
        self.assertEqual(check_int(999999999999), 999999999999)
181
        self.assertEqual(check_int('10'), 10)
182

183
        with self.assertRaises(ValueError):
184
            check_int('foo')
185

186
        self.assertEqual(check_int(10, minimum=9), 10)
187
        self.assertEqual(check_int(10, minimum=10), 10)
188
        with self.assertRaises(ValueError):
189
            check_int(10, minimum=11)
190

191
        self.assertEqual(check_int(10, minimum=9, exclusive_minimum=True), 10)
192
        with self.assertRaises(ValueError):
193
            check_int(10, minimum=10, exclusive_minimum=True)
194
        with self.assertRaises(ValueError):
195
            check_int(10, minimum=11, exclusive_minimum=True)
196

197
        self.assertEqual(check_int(10, maximum=11), 10)
198
        self.assertEqual(check_int(10, maximum=10), 10)
199
        with self.assertRaises(ValueError):
200
            check_int(10, maximum=9)
201

202
        self.assertEqual(check_int(10, maximum=11, exclusive_minimum=True), 10)
203
        with self.assertRaises(ValueError):
204
            check_int(10, maximum=10, exclusive_maximum=True)
205
        with self.assertRaises(ValueError):
206
            check_int(10, maximum=9, exclusive_maximum=True)
207

208
        self.assertEqual(check_int(10, multiple_of=5), 10)
209
        with self.assertRaises(ValueError):
210
            check_int(10, multiple_of=3)
211

212
    def test_check_float(self):
213
        self.assertEqual(check_float(123.567), 123.567)
214
        self.assertEqual(check_float(999999999999.999), 999999999999.999)
215
        self.assertEqual(check_float('123.567'), 123.567)
216

217
        with self.assertRaises(ValueError):
218
            check_float('foo')
219

220
        self.assertEqual(check_float(123.567, minimum=123.566), 123.567)
221
        self.assertEqual(check_float(123.567, minimum=123.567), 123.567)
222
        with self.assertRaises(ValueError):
223
            check_float(123.567, minimum=123.577)
224

225
        self.assertEqual(
226
            check_float(
227
                123.567, minimum=123.566,
228
                exclusive_minimum=True,
229
            ), 123.567,
230
        )
231
        with self.assertRaises(ValueError):
232
            check_float(123.567, minimum=123.567, exclusive_minimum=True)
233
        with self.assertRaises(ValueError):
234
            check_float(123.567, minimum=123.568, exclusive_minimum=True)
235

236
        self.assertEqual(check_float(123.567, maximum=123.568), 123.567)
237
        self.assertEqual(check_float(123.567, maximum=123.567), 123.567)
238
        with self.assertRaises(ValueError):
239
            check_float(123.567, maximum=123.566)
240

241
        self.assertEqual(
242
            check_float(
243
                123.567, maximum=123.567,
244
                exclusive_minimum=True,
245
            ), 123.567,
246
        )
247
        with self.assertRaises(ValueError):
248
            check_float(123.567, maximum=123.567, exclusive_maximum=True)
249
        with self.assertRaises(ValueError):
250
            check_float(123.567, maximum=123.566, exclusive_maximum=True)
251

252
        with self.assertRaises(ValueError):
253
            check_float(123.567, multiple_of=3)
254

255
    def test_check_str(self):
256
        self.assertEqual(check_str('hi there'), 'hi there')
257
        self.assertTrue(isinstance(check_str('hi there'), str))
258

259
        self.assertEqual(check_str('hi there', pattern=r' th'), 'hi there')
260
        with self.assertRaises(ValueError):
261
            check_str('hi there', pattern=r' th$')
262

263
        self.assertEqual(check_str('hi there', max_length=20), 'hi there')
264
        self.assertEqual(check_str('hi there', max_length=8), 'hi there')
265
        with self.assertRaises(ValueError):
266
            check_str('hi there', max_length=7)
267

268
        self.assertEqual(check_str('hi there', min_length=3), 'hi there')
269
        self.assertEqual(check_str('hi there', min_length=8), 'hi there')
270
        with self.assertRaises(ValueError):
271
            check_str('hi there', min_length=9)
272

273
        self.assertEqual(
274
            check_str('hi there', valid_values=['hi there', 'bye now']),
275
            'hi there',
276
        )
277
        with self.assertRaises(ValueError):
278
            check_str('foo', valid_values=['hi there', 'bye now'])
279

280
        # Invalid utf8 data
281
        with self.assertRaises(ValueError):
282
            check_str(b'\xff\xfeW[')
283

284
    def test_check_url(self):
285
        self.assertEqual(check_url('hi there'), 'hi there')
286
        self.assertTrue(isinstance(check_url('hi there'), str))
287

288
        # Invalid utf8 data
289
        with self.assertRaises(ValueError):
290
            check_url(b'\xff\xfeW[')
291

292
    def test_check_bool(self):
293
        self.assertEqual(check_bool(True), True)
294
        self.assertEqual(check_bool(False), False)
295
        self.assertEqual(check_bool(1), True)
296
        self.assertEqual(check_bool(0), False)
297
        self.assertEqual(check_bool('yes'), True)
298
        self.assertEqual(check_bool('no'), False)
299
        self.assertEqual(check_bool('T'), True)
300
        self.assertEqual(check_bool('F'), False)
301
        self.assertEqual(check_bool('true'), True)
302
        self.assertEqual(check_bool('false'), False)
303
        self.assertEqual(check_bool('on'), True)
304
        self.assertEqual(check_bool('off'), False)
305
        self.assertEqual(check_bool('enabled'), True)
306
        self.assertEqual(check_bool('disabled'), False)
307

308
        with self.assertRaises(ValueError):
309
            check_bool(2)
310
        with self.assertRaises(ValueError):
311
            check_bool('foo')
312
        with self.assertRaises(ValueError):
313
            check_bool(1.1)
314

315

316
if __name__ == '__main__':
317
    import nose2
318
    nose2.main()
319

320
Product

Resources

Company
