| 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() |