Debian Codegraph @

Lib/test/test_dbm_sqlite3.py

raw
1 import os
2 import stat
3 import sys
4 import unittest
5 from contextlib import closing
6 from functools import partial
7 from pathlib import Path
8 from test.support import import_helper, os_helper
9
10 dbm_sqlite3 = import_helper.import_module("dbm.sqlite3")
11 # N.B. The test will fail on some platforms without sqlite3
12 # if the sqlite3 import is above the import of dbm.sqlite3.
13 # This is deliberate: if the import helper managed to import dbm.sqlite3,
14 # we must inevitably be able to import sqlite3. Else, we have a problem.
15 import sqlite3
16 from dbm.sqlite3 import _normalize_uri
17
18
19 root_in_posix = False
20 if hasattr(os, 'geteuid'):
21 root_in_posix = (os.geteuid() == 0)
22
23
24 class _SQLiteDbmTests(unittest.TestCase):
25
26 def setUp(self):
27 self.filename = os_helper.TESTFN
28 db = dbm_sqlite3.open(self.filename, "c")
29 db.close()
30
31 def tearDown(self):
32 for suffix in "", "-wal", "-shm":
33 os_helper.unlink(self.filename + suffix)
34
35
36 class URI(unittest.TestCase):
37
38 def test_uri_substitutions(self):
39 dataset = (
40 ("/absolute/////b/c", "/absolute/b/c"),
41 ("PRE#MID##END", "PRE%23MID%23%23END"),
42 ("%#?%%#", "%25%23%3F%25%25%23"),
43 )
44 for path, normalized in dataset:
45 with self.subTest(path=path, normalized=normalized):
46 self.assertEndsWith(_normalize_uri(path), normalized)
47
48 @unittest.skipUnless(sys.platform == "win32", "requires Windows")
49 def test_uri_windows(self):
50 dataset = (
51 # Relative subdir.
52 (r"2018\January.xlsx",
53 "2018/January.xlsx"),
54 # Absolute with drive letter.
55 (r"C:\Projects\apilibrary\apilibrary.sln",
56 "/C:/Projects/apilibrary/apilibrary.sln"),
57 # Relative with drive letter.
58 (r"C:Projects\apilibrary\apilibrary.sln",
59 "/C:Projects/apilibrary/apilibrary.sln"),
60 )
61 for path, normalized in dataset:
62 with self.subTest(path=path, normalized=normalized):
63 if not Path(path).is_absolute():
64 self.skipTest(f"skipping relative path: {path!r}")
65 self.assertEndsWith(_normalize_uri(path), normalized)
66
67
68 class ReadOnly(_SQLiteDbmTests):
69
70 def setUp(self):
71 super().setUp()
72 with dbm_sqlite3.open(self.filename, "w") as db:
73 db[b"key1"] = "value1"
74 db[b"key2"] = "value2"
75 self.db = dbm_sqlite3.open(self.filename, "r")
76
77 def tearDown(self):
78 self.db.close()
79 super().tearDown()
80
81 def test_readonly_read(self):
82 self.assertEqual(self.db[b"key1"], b"value1")
83 self.assertEqual(self.db[b"key2"], b"value2")
84
85 def test_readonly_write(self):
86 with self.assertRaises(dbm_sqlite3.error):
87 self.db[b"new"] = "value"
88
89 def test_readonly_delete(self):
90 with self.assertRaises(dbm_sqlite3.error):
91 del self.db[b"key1"]
92
93 def test_readonly_keys(self):
94 self.assertEqual(self.db.keys(), [b"key1", b"key2"])
95
96 def test_readonly_iter(self):
97 self.assertEqual([k for k in self.db], [b"key1", b"key2"])
98
99
100 @unittest.skipIf(root_in_posix, "test is meanless with root privilege")
101 class ReadOnlyFilesystem(unittest.TestCase):
102
103 def setUp(self):
104 self.test_dir = os_helper.TESTFN
105 self.addCleanup(os_helper.rmtree, self.test_dir)
106 os.mkdir(self.test_dir)
107 self.db_path = os.path.join(self.test_dir, "test.db")
108
109 db = dbm_sqlite3.open(self.db_path, "c")
110 db[b"key"] = b"value"
111 db.close()
112
113 def test_readonly_file_read(self):
114 os.chmod(self.db_path, stat.S_IREAD)
115 with dbm_sqlite3.open(self.db_path, "r") as db:
116 self.assertEqual(db[b"key"], b"value")
117
118 def test_readonly_file_write(self):
119 os.chmod(self.db_path, stat.S_IREAD)
120 with dbm_sqlite3.open(self.db_path, "w") as db:
121 with self.assertRaises(dbm_sqlite3.error):
122 db[b"newkey"] = b"newvalue"
123
124 def test_readonly_dir_read(self):
125 os.chmod(self.test_dir, stat.S_IREAD | stat.S_IEXEC)
126 with dbm_sqlite3.open(self.db_path, "r") as db:
127 self.assertEqual(db[b"key"], b"value")
128
129 def test_readonly_dir_write(self):
130 os.chmod(self.test_dir, stat.S_IREAD | stat.S_IEXEC)
131 with dbm_sqlite3.open(self.db_path, "w") as db:
132 try:
133 db[b"newkey"] = b"newvalue"
134 modified = True # on Windows and macOS
135 except dbm_sqlite3.error:
136 modified = False
137 with dbm_sqlite3.open(self.db_path, "r") as db:
138 if modified:
139 self.assertEqual(db[b"newkey"], b"newvalue")
140 else:
141 self.assertNotIn(b"newkey", db)
142
143
144 class ReadWrite(_SQLiteDbmTests):
145
146 def setUp(self):
147 super().setUp()
148 self.db = dbm_sqlite3.open(self.filename, "w")
149
150 def tearDown(self):
151 self.db.close()
152 super().tearDown()
153
154 def db_content(self):
155 with closing(sqlite3.connect(self.filename)) as cx:
156 keys = [r[0] for r in cx.execute("SELECT key FROM Dict")]
157 vals = [r[0] for r in cx.execute("SELECT value FROM Dict")]
158 return keys, vals
159
160 def test_readwrite_unique_key(self):
161 self.db["key"] = "value"
162 self.db["key"] = "other"
163 keys, vals = self.db_content()
164 self.assertEqual(keys, [b"key"])
165 self.assertEqual(vals, [b"other"])
166
167 def test_readwrite_delete(self):
168 self.db["key"] = "value"
169 self.db["new"] = "other"
170
171 del self.db[b"new"]
172 keys, vals = self.db_content()
173 self.assertEqual(keys, [b"key"])
174 self.assertEqual(vals, [b"value"])
175
176 del self.db[b"key"]
177 keys, vals = self.db_content()
178 self.assertEqual(keys, [])
179 self.assertEqual(vals, [])
180
181 def test_readwrite_null_key(self):
182 with self.assertRaises(dbm_sqlite3.error):
183 self.db[None] = "value"
184
185 def test_readwrite_null_value(self):
186 with self.assertRaises(dbm_sqlite3.error):
187 self.db[b"key"] = None
188
189
190 class Misuse(_SQLiteDbmTests):
191
192 def setUp(self):
193 super().setUp()
194 self.db = dbm_sqlite3.open(self.filename, "w")
195
196 def tearDown(self):
197 self.db.close()
198 super().tearDown()
199
200 def test_misuse_double_create(self):
201 self.db["key"] = "value"
202 with dbm_sqlite3.open(self.filename, "c") as db:
203 self.assertEqual(db[b"key"], b"value")
204
205 def test_misuse_double_close(self):
206 self.db.close()
207
208 def test_misuse_invalid_flag(self):
209 regex = "must be.*'r'.*'w'.*'c'.*'n', not 'invalid'"
210 with self.assertRaisesRegex(ValueError, regex):
211 dbm_sqlite3.open(self.filename, flag="invalid")
212
213 def test_misuse_double_delete(self):
214 self.db["key"] = "value"
215 del self.db[b"key"]
216 with self.assertRaises(KeyError):
217 del self.db[b"key"]
218
219 def test_misuse_invalid_key(self):
220 with self.assertRaises(KeyError):
221 self.db[b"key"]
222
223 def test_misuse_iter_close1(self):
224 self.db["1"] = 1
225 it = iter(self.db)
226 self.db.close()
227 with self.assertRaises(dbm_sqlite3.error):
228 next(it)
229
230 def test_misuse_iter_close2(self):
231 self.db["1"] = 1
232 self.db["2"] = 2
233 it = iter(self.db)
234 next(it)
235 self.db.close()
236 with self.assertRaises(dbm_sqlite3.error):
237 next(it)
238
239 def test_misuse_use_after_close(self):
240 self.db.close()
241 with self.assertRaises(dbm_sqlite3.error):
242 self.db[b"read"]
243 with self.assertRaises(dbm_sqlite3.error):
244 self.db[b"write"] = "value"
245 with self.assertRaises(dbm_sqlite3.error):
246 del self.db[b"del"]
247 with self.assertRaises(dbm_sqlite3.error):
248 len(self.db)
249 with self.assertRaises(dbm_sqlite3.error):
250 self.db.keys()
251
252 def test_misuse_reinit(self):
253 with self.assertRaises(dbm_sqlite3.error):
254 self.db.__init__("new.db", flag="n", mode=0o666)
255
256 def test_misuse_empty_filename(self):
257 for flag in "r", "w", "c", "n":
258 with self.assertRaises(dbm_sqlite3.error):
259 db = dbm_sqlite3.open("", flag="c")
260
261
262 class DataTypes(_SQLiteDbmTests):
263
264 dataset = (
265 # (raw, coerced)
266 (42, b"42"),
267 (3.14, b"3.14"),
268 ("string", b"string"),
269 (b"bytes", b"bytes"),
270 )
271
272 def setUp(self):
273 super().setUp()
274 self.db = dbm_sqlite3.open(self.filename, "w")
275
276 def tearDown(self):
277 self.db.close()
278 super().tearDown()
279
280 def test_datatypes_values(self):
281 for raw, coerced in self.dataset:
282 with self.subTest(raw=raw, coerced=coerced):
283 self.db["key"] = raw
284 self.assertEqual(self.db[b"key"], coerced)
285
286 def test_datatypes_keys(self):
287 for raw, coerced in self.dataset:
288 with self.subTest(raw=raw, coerced=coerced):
289 self.db[raw] = "value"
290 self.assertEqual(self.db[coerced], b"value")
291 # Raw keys are silently coerced to bytes.
292 self.assertEqual(self.db[raw], b"value")
293 del self.db[raw]
294
295 def test_datatypes_replace_coerced(self):
296 self.db["10"] = "value"
297 self.db[b"10"] = "value"
298 self.db[10] = "value"
299 self.assertEqual(self.db.keys(), [b"10"])
300
301
302 class CorruptDatabase(_SQLiteDbmTests):
303 """Verify that database exceptions are raised as dbm.sqlite3.error."""
304
305 def setUp(self):
306 super().setUp()
307 with closing(sqlite3.connect(self.filename)) as cx:
308 with cx:
309 cx.execute("DROP TABLE IF EXISTS Dict")
310 cx.execute("CREATE TABLE Dict (invalid_schema)")
311
312 def check(self, flag, fn, should_succeed=False):
313 with closing(dbm_sqlite3.open(self.filename, flag)) as db:
314 with self.assertRaises(dbm_sqlite3.error):
315 fn(db)
316
317 @staticmethod
318 def read(db):
319 return db["key"]
320
321 @staticmethod
322 def write(db):
323 db["key"] = "value"
324
325 @staticmethod
326 def iter(db):
327 next(iter(db))
328
329 @staticmethod
330 def keys(db):
331 db.keys()
332
333 @staticmethod
334 def del_(db):
335 del db["key"]
336
337 @staticmethod
338 def len_(db):
339 len(db)
340
341 def test_corrupt_readwrite(self):
342 for flag in "r", "w", "c":
343 with self.subTest(flag=flag):
344 check = partial(self.check, flag=flag)
345 check(fn=self.read)
346 check(fn=self.write)
347 check(fn=self.iter)
348 check(fn=self.keys)
349 check(fn=self.del_)
350 check(fn=self.len_)
351
352 def test_corrupt_force_new(self):
353 with closing(dbm_sqlite3.open(self.filename, "n")) as db:
354 db["foo"] = "write"
355 _ = db[b"foo"]
356 next(iter(db))
357 del db[b"foo"]
358
359
360 if __name__ == "__main__":
361 unittest.main()