CoCalc -- test

GitHub Repository: singlestore-labs/singlestoredb-python
Path: blob/main/singlestoredb/tests/test_xdict.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 copy
22
import unittest
23

24
from singlestoredb.utils.xdict import xadict
25
from singlestoredb.utils.xdict import xdict
26

27
out1 = {
28
    'a': {'one': 1},
29
    'b': {'two': 2},
30
    'c': {
31
        'three': {'nest': 3},
32
        'four': {
33
            'nest': {'double': 4},
34
        },
35
    },
36
}
37

38
flatout1 = {
39
    'a.one': 1,
40
    'b.two': 2,
41
    'c.three.nest': 3,
42
    'c.four.nest.double': 4,
43
}
44

45

46
class TestXDict(unittest.TestCase):
47

48
    def test_constructor(self):
49
        x = xdict(one=1, two=2, three=3)
50
        self.assertEqual(x, dict(one=1, two=2, three=3))
51

52
        x = xdict([('a.one', 1), ('b.two', 2), ('c.three.nest', 3)])
53
        self.assertEqual(
54
            x, {
55
                'a': {'one': 1},
56
                'b': {'two': 2},
57
                'c': {
58
                    'three': {'nest': 3},
59
                },
60
            },
61
        )
62

63
        x = xdict([
64
            ('a.one', 1), ('b.two', 2), ('c.three.nest', 3),
65
            ('c.four.nest.double', 4),
66
        ])
67
        self.assertEqual(x, out1)
68

69
        x = xdict(out1)
70
        self.assertEqual(x, out1)
71

72
        x = xdict(flatout1)
73
        self.assertEqual(x, out1)
74

75
        x = xdict(**out1)
76
        self.assertEqual(x, out1)
77

78
        x = xdict(**flatout1)
79
        self.assertEqual(x, out1)
80

81
    def test_setitem(self):
82
        x = xdict()
83
        x['a.one'] = 1
84
        x['b.two'] = 2
85
        x['c.three.nest'] = 3
86
        x['c.four.nest.double'] = 4
87
        self.assertEqual(x, out1)
88

89
        x[100] = 1000
90
        self.assertEqual(x[100], 1000)
91

92
        x = xdict()
93
        x['a.one'] = 1
94
        x['b.two'] = 2
95
        x['c.three.nest'] = 3
96
        x['c.four'] = {'nest': {'double': 4}}
97
        self.assertEqual(x, out1)
98

99
    def test_getitem(self):
100
        x = xdict(out1)
101
        self.assertEqual(x['a.one'], 1)
102
        self.assertEqual(x['b.two'], 2)
103
        self.assertEqual(x['c.three.nest'], 3)
104
        self.assertEqual(x['c.four.nest.double'], 4)
105

106
        self.assertEqual(x['a'], {'one': 1})
107
        self.assertEqual(x['b'], {'two': 2})
108
        self.assertEqual(x['c'], {'three': {'nest': 3}, 'four': {'nest': {'double': 4}}})
109
        self.assertEqual(x['c.three'], {'nest': 3})
110
        self.assertEqual(x['c.four'], {'nest': {'double': 4}})
111
        self.assertEqual(x['c.four.nest'], {'double': 4})
112

113
        self.assertEqual(x['a'], {'one': 1})
114
        self.assertEqual(x['a']['one'], 1)
115
        self.assertEqual(x['b'], {'two': 2})
116
        self.assertEqual(x['b']['two'], 2)
117
        self.assertEqual(x['c'], {'three': {'nest': 3}, 'four': {'nest': {'double': 4}}})
118
        self.assertEqual(x['c']['three'], {'nest': 3})
119
        self.assertEqual(x['c']['three']['nest'], 3)
120
        self.assertEqual(x['c']['four'], {'nest': {'double': 4}})
121
        self.assertEqual(x['c']['four']['nest'], {'double': 4})
122
        self.assertEqual(x['c']['four']['nest']['double'], 4)
123

124
    def test_get(self):
125
        x = xdict(out1)
126

127
        self.assertEqual(x.get('a', 1000), {'one': 1})
128
        self.assertEqual(x.get('a.one', 1000), 1)
129
        self.assertEqual(x.get('a.does.not.exist', 1000), 1000)
130

131
    def test_delitem(self):
132
        newout1 = copy.deepcopy(out1)
133
        x = xdict(out1)
134

135
        del x['a']
136
        del newout1['a']
137
        self.assertEqual(x, newout1)
138

139
        del x['c.four.nest']
140
        del newout1['c']['four']['nest']
141
        self.assertEqual(x, newout1)
142

143
        with self.assertRaises(KeyError):
144
            del x['a.does.not.exist']
145

146
    def test_flattened(self):
147
        x = xdict(out1)
148
        self.assertEqual(x.flattened(), flatout1)
149

150
    def test_setdefault(self):
151
        x = xdict(out1)
152

153
        self.assertEqual(x.setdefault('a.one'), 1)
154
        self.assertEqual(x.setdefault('b.two'), 2)
155
        self.assertEqual(x.setdefault('b'), {'two': 2})
156

157
        self.assertEqual(x.setdefault('w.none'), None)
158
        self.assertEqual(x['w.none'], None)
159
        self.assertEqual(x['w']['none'], None)
160
        self.assertEqual(x.setdefault('x.y.z', 200), 200)
161
        self.assertEqual(x['x.y.z'], 200)
162
        self.assertEqual(x['x']['y']['z'], 200)
163
        self.assertEqual(x.setdefault('x.y.z', 10), 200)
164
        self.assertEqual(x['x.y.z'], 200)
165
        self.assertEqual(x['x']['y']['z'], 200)
166
        self.assertEqual(x['x']['y'], {'z': 200})
167

168
        self.assertEqual(x.setdefault('does.not.exist', {'new': 'key'}), {'new': 'key'})
169
        self.assertTrue(isinstance(x.setdefault('does.not.exist', {'new': 'key'}), xdict))
170

171
    def test_json(self):
172
        x = xdict(out1)
173
        self.assertEqual(xdict.from_json(x.to_json()), out1)
174

175
    def test_flat(self):
176
        x = xdict(out1)
177

178
        self.assertEqual(sorted(x.flatkeys()), sorted(flatout1.keys()))
179
        self.assertEqual(sorted(x.flatvalues()), sorted(flatout1.values()))
180
        self.assertEqual(sorted(x.flatitems()), sorted(flatout1.items()))
181

182
        if hasattr(flatout1, 'iterkeys'):
183
            self.assertEqual(sorted(x.iterflatkeys()), sorted(flatout1.iterkeys()))
184
        if hasattr(flatout1, 'itervalues'):
185
            self.assertEqual(sorted(x.iterflatvalues()), sorted(flatout1.itervalues()))
186
        if hasattr(flatout1, 'iteritems'):
187
            self.assertEqual(sorted(x.iterflatitems()), sorted(flatout1.iteritems()))
188

189
        if hasattr(flatout1, 'iterkeys'):
190
            self.assertEqual(sorted(x.viewflatkeys()), sorted(flatout1.iterkeys()))
191
        if hasattr(flatout1, 'itervalues'):
192
            self.assertEqual(sorted(x.viewflatvalues()), sorted(flatout1.itervalues()))
193
        if hasattr(flatout1, 'iteritems'):
194
            self.assertEqual(sorted(x.viewflatitems()), sorted(flatout1.iteritems()))
195

196
    def test_contains(self):
197
        x = xdict(out1)
198

199
        self.assertTrue('a' in x)
200
        self.assertTrue('a.one' in x)
201
        self.assertTrue('b' in x)
202
        self.assertTrue('c.four' in x)
203
        self.assertTrue('c.four.nest' in x)
204
        self.assertTrue('c.four.nest.double' in x)
205
        self.assertFalse('z' in x)
206
        self.assertFalse('four' in x)
207

208
        self.assertTrue(x.has_key('a'))  # noqa: W601
209
        self.assertTrue(x.has_key('a.one'))  # noqa: W601
210
        self.assertTrue(x.has_key('b'))  # noqa: W601
211
        self.assertTrue(x.has_key('c.four'))  # noqa: W601
212
        self.assertTrue(x.has_key('c.four.nest'))  # noqa: W601
213
        self.assertTrue(x.has_key('c.four.nest.double'))  # noqa: W601
214
        self.assertFalse(x.has_key('z'))  # noqa: W601
215
        self.assertFalse(x.has_key('four'))  # noqa: W601
216

217
    def test_pop(self):
218
        x = xdict(out1)
219

220
        self.assertEqual(x, out1)
221

222
        self.assertEqual(x.pop('a.one'), out1['a']['one'])
223
        self.assertEqual(x.pop('b.two'), out1['b']['two'])
224
        self.assertEqual(x.pop('c'), out1['c'])
225

226
        self.assertEqual(x, {'a': {}, 'b': {}})
227

228
        with self.assertRaises(KeyError):
229
            x.pop('a.does.not.exist')
230

231
        self.assertEqual(x.pop('a.does.not.exist', 1000), 1000)
232

233
    def test_copy(self):
234
        w = xdict(out1)
235

236
        x = w.copy()
237

238
        self.assertEqual(w, x)
239
        self.assertTrue(w is not x)
240
        self.assertTrue(w['a'] is x['a'])
241
        self.assertTrue(w['b'] is x['b'])
242
        self.assertTrue(w['c'] is x['c'])
243

244
        y = copy.copy(w)
245

246
        self.assertEqual(w, y)
247
        self.assertTrue(w is not y)
248
        self.assertTrue(w['a'] is y['a'])
249
        self.assertTrue(w['a.one'] is y['a.one'])
250
        self.assertTrue(w['b'] is y['b'])
251
        self.assertTrue(w['b.two'] is y['b.two'])
252
        self.assertTrue(w['c'] is y['c'])
253
        self.assertTrue(w['c.three'] is y['c.three'])
254

255
        z = copy.deepcopy(w)
256

257
        # TODO: Deepcopy is only shallow copying
258
        self.assertEqual(w, z)
259
        self.assertTrue(w is not z)
260
        self.assertTrue(w['a'] is not z['a'])
261
#       self.assertTrue(w['a.one'] is not z['a.one'])
262
        self.assertTrue(w['b'] is not z['b'])
263
#       self.assertTrue(w['b.two'] is not z['b.two'])
264
        self.assertTrue(w['c'] is not z['c'])
265
#       self.assertTrue(w['c.three'] is not z['c.three'])
266

267
    def test_attrs(self):
268
        x = xadict(out1)
269

270
        self.assertEqual(x.a, x['a'])
271
        self.assertEqual(x.a.one, x['a.one'])
272
        self.assertEqual(x.a.one, x['a']['one'])
273
        self.assertEqual(x.b, x['b'])
274
        self.assertEqual(x.b.two, x['b.two'])
275
        self.assertEqual(x.b.two, x['b']['two'])
276
        self.assertEqual(x.c, x['c'])
277
        self.assertEqual(x.c.three, x['c.three'])
278
        self.assertEqual(x.c.three, x['c']['three'])
279

280
        x.a.one = 100
281
        x.c.four.nest = {'float': 5}
282

283
        self.assertEqual(x['a.one'], 100)
284
        self.assertEqual(x['c.four.nest'], {'float': 5})
285

286
        del x.c.three
287

288
        self.assertEqual(x.c, {'four': {'nest': {'float': 5}}})
289

290
        del x.c
291

292
        self.assertEqual(x, {'a': {'one': 100}, 'b': {'two': 2}})
293

294
        del x.a
295
        del x.b
296

297
        self.assertEqual(x, {})
298

299
        # Non-existent keys
300
        x.foo.bar.xxx = 10
301
        x.foo.baz = 'hi there'
302

303
        self.assertEqual(x, {'foo': {'bar': {'xxx': 10}, 'baz': 'hi there'}})
304

305
    def test_ints(self):
306
        x = xadict(out1)
307

308
        out1int = dict(out1)
309
        out1int['d'] = {}
310
        out1int['d'][0] = dict(hi='there', bye='now')
311
        out1int['d'][1] = dict(test='value')
312
        out1int['d'][2] = 100
313

314
        x.d[0].hi = 'there'
315
        x.d[0].bye = 'now'
316
        x.d[1].test = 'value'
317
        x.d[2] = 100
318

319
        self.assertEqual(x, out1int)
320

321
        # Flat
322
        flatout1int = dict(flatout1)
323
        flatout1int['d[0].hi'] = 'there'
324
        flatout1int['d[0].bye'] = 'now'
325
        flatout1int['d[1].test'] = 'value'
326
        flatout1int['d[2]'] = 100
327

328
        self.assertEqual(x.flattened(), flatout1int)
329

330

331
if __name__ == '__main__':
332
    import nose2
333
    nose2.main()
334

335
Product

Resources

Company
