| 1 |
"""Test script for the dbm.open function based on testdumbdbm.py""" |
| 2 |
|
| 3 |
import unittest |
| 4 |
import dbm |
| 5 |
import os |
| 6 |
from test.support import import_helper |
| 7 |
from test.support import os_helper |
| 8 |
|
| 9 |
|
| 10 |
try: |
| 11 |
from dbm import sqlite3 as dbm_sqlite3 |
| 12 |
except ImportError: |
| 13 |
dbm_sqlite3 = None |
| 14 |
|
| 15 |
|
| 16 |
try: |
| 17 |
from dbm import ndbm |
| 18 |
except ImportError: |
| 19 |
ndbm = None |
| 20 |
|
| 21 |
dirname = os_helper.TESTFN |
| 22 |
_fname = os.path.join(dirname, os_helper.TESTFN) |
| 23 |
|
| 24 |
# |
| 25 |
# Iterates over every database module supported by dbm currently available. |
| 26 |
# |
| 27 |
def dbm_iterator(): |
| 28 |
for name in dbm._names: |
| 29 |
try: |
| 30 |
mod = __import__(name, fromlist=['open']) |
| 31 |
except ImportError: |
| 32 |
continue |
| 33 |
dbm._modules[name] = mod |
| 34 |
yield mod |
| 35 |
|
| 36 |
# |
| 37 |
# Clean up all scratch databases we might have created during testing |
| 38 |
# |
| 39 |
def cleaunup_test_dir(): |
| 40 |
os_helper.rmtree(dirname) |
| 41 |
|
| 42 |
def setup_test_dir(): |
| 43 |
cleaunup_test_dir() |
| 44 |
os.mkdir(dirname) |
| 45 |
|
| 46 |
|
| 47 |
class AnyDBMTestCase: |
| 48 |
_dict = {'a': b'Python:', |
| 49 |
'b': b'Programming', |
| 50 |
'c': b'the', |
| 51 |
'd': b'way', |
| 52 |
'f': b'Guido', |
| 53 |
'g': b'intended', |
| 54 |
} |
| 55 |
|
| 56 |
def init_db(self): |
| 57 |
f = dbm.open(_fname, 'n') |
| 58 |
for k in self._dict: |
| 59 |
f[k.encode("ascii")] = self._dict[k] |
| 60 |
f.close() |
| 61 |
|
| 62 |
def keys_helper(self, f): |
| 63 |
keys = sorted(k.decode("ascii") for k in f.keys()) |
| 64 |
dkeys = sorted(self._dict.keys()) |
| 65 |
self.assertEqual(keys, dkeys) |
| 66 |
return keys |
| 67 |
|
| 68 |
def test_error(self): |
| 69 |
self.assertIsSubclass(self.module.error, OSError) |
| 70 |
|
| 71 |
def test_anydbm_not_existing(self): |
| 72 |
self.assertRaises(dbm.error, dbm.open, _fname) |
| 73 |
|
| 74 |
def test_anydbm_creation(self): |
| 75 |
f = dbm.open(_fname, 'c') |
| 76 |
self.assertEqual(list(f.keys()), []) |
| 77 |
for key in self._dict: |
| 78 |
f[key.encode("ascii")] = self._dict[key] |
| 79 |
self.read_helper(f) |
| 80 |
f.close() |
| 81 |
|
| 82 |
def test_anydbm_creation_n_file_exists_with_invalid_contents(self): |
| 83 |
# create an empty file |
| 84 |
os_helper.create_empty_file(_fname) |
| 85 |
with dbm.open(_fname, 'n') as f: |
| 86 |
self.assertEqual(len(f), 0) |
| 87 |
|
| 88 |
def test_anydbm_modification(self): |
| 89 |
self.init_db() |
| 90 |
f = dbm.open(_fname, 'c') |
| 91 |
self._dict['g'] = f[b'g'] = b"indented" |
| 92 |
self.read_helper(f) |
| 93 |
# setdefault() works as in the dict interface |
| 94 |
self.assertEqual(f.setdefault(b'xxx', b'foo'), b'foo') |
| 95 |
self.assertEqual(f[b'xxx'], b'foo') |
| 96 |
f.close() |
| 97 |
|
| 98 |
def test_anydbm_read(self): |
| 99 |
self.init_db() |
| 100 |
f = dbm.open(_fname, 'r') |
| 101 |
self.read_helper(f) |
| 102 |
# get() works as in the dict interface |
| 103 |
self.assertEqual(f.get(b'a'), self._dict['a']) |
| 104 |
self.assertEqual(f.get(b'xxx', b'foo'), b'foo') |
| 105 |
self.assertIsNone(f.get(b'xxx')) |
| 106 |
with self.assertRaises(KeyError): |
| 107 |
f[b'xxx'] |
| 108 |
f.close() |
| 109 |
|
| 110 |
def test_anydbm_keys(self): |
| 111 |
self.init_db() |
| 112 |
f = dbm.open(_fname, 'r') |
| 113 |
keys = self.keys_helper(f) |
| 114 |
f.close() |
| 115 |
|
| 116 |
def test_empty_value(self): |
| 117 |
if getattr(dbm._defaultmod, 'library', None) == 'Berkeley DB': |
| 118 |
self.skipTest("Berkeley DB doesn't distinguish the empty value " |
| 119 |
"from the absent one") |
| 120 |
f = dbm.open(_fname, 'c') |
| 121 |
self.assertEqual(f.keys(), []) |
| 122 |
f[b'empty'] = b'' |
| 123 |
self.assertEqual(f.keys(), [b'empty']) |
| 124 |
self.assertIn(b'empty', f) |
| 125 |
self.assertEqual(f[b'empty'], b'') |
| 126 |
self.assertEqual(f.get(b'empty'), b'') |
| 127 |
self.assertEqual(f.setdefault(b'empty'), b'') |
| 128 |
f.close() |
| 129 |
|
| 130 |
def test_anydbm_access(self): |
| 131 |
self.init_db() |
| 132 |
f = dbm.open(_fname, 'r') |
| 133 |
key = "a".encode("ascii") |
| 134 |
self.assertIn(key, f) |
| 135 |
assert(f[key] == b"Python:") |
| 136 |
f.close() |
| 137 |
|
| 138 |
def test_open_with_bytes(self): |
| 139 |
dbm.open(os.fsencode(_fname), "c").close() |
| 140 |
|
| 141 |
def test_open_with_pathlib_path(self): |
| 142 |
dbm.open(os_helper.FakePath(_fname), "c").close() |
| 143 |
|
| 144 |
def test_open_with_pathlib_path_bytes(self): |
| 145 |
dbm.open(os_helper.FakePath(os.fsencode(_fname)), "c").close() |
| 146 |
|
| 147 |
def read_helper(self, f): |
| 148 |
keys = self.keys_helper(f) |
| 149 |
for key in self._dict: |
| 150 |
self.assertEqual(self._dict[key], f[key.encode("ascii")]) |
| 151 |
|
| 152 |
def test_keys(self): |
| 153 |
with dbm.open(_fname, 'c') as d: |
| 154 |
self.assertEqual(d.keys(), []) |
| 155 |
a = [(b'a', b'b'), (b'12345678910', b'019237410982340912840198242')] |
| 156 |
for k, v in a: |
| 157 |
d[k] = v |
| 158 |
self.assertEqual(sorted(d.keys()), sorted(k for (k, v) in a)) |
| 159 |
for k, v in a: |
| 160 |
self.assertIn(k, d) |
| 161 |
self.assertEqual(d[k], v) |
| 162 |
self.assertNotIn(b'xxx', d) |
| 163 |
self.assertRaises(KeyError, lambda: d[b'xxx']) |
| 164 |
|
| 165 |
def test_clear(self): |
| 166 |
with dbm.open(_fname, 'c') as d: |
| 167 |
self.assertEqual(d.keys(), []) |
| 168 |
a = [(b'a', b'b'), (b'12345678910', b'019237410982340912840198242')] |
| 169 |
for k, v in a: |
| 170 |
d[k] = v |
| 171 |
for k, _ in a: |
| 172 |
self.assertIn(k, d) |
| 173 |
self.assertEqual(len(d), len(a)) |
| 174 |
|
| 175 |
d.clear() |
| 176 |
self.assertEqual(len(d), 0) |
| 177 |
for k, _ in a: |
| 178 |
self.assertNotIn(k, d) |
| 179 |
|
| 180 |
def setUp(self): |
| 181 |
self.addCleanup(setattr, dbm, '_defaultmod', dbm._defaultmod) |
| 182 |
dbm._defaultmod = self.module |
| 183 |
self.addCleanup(cleaunup_test_dir) |
| 184 |
setup_test_dir() |
| 185 |
|
| 186 |
|
| 187 |
class WhichDBTestCase(unittest.TestCase): |
| 188 |
def test_whichdb(self): |
| 189 |
self.addCleanup(setattr, dbm, '_defaultmod', dbm._defaultmod) |
| 190 |
_bytes_fname = os.fsencode(_fname) |
| 191 |
fnames = [_fname, os_helper.FakePath(_fname), |
| 192 |
_bytes_fname, os_helper.FakePath(_bytes_fname)] |
| 193 |
for module in dbm_iterator(): |
| 194 |
# Check whether whichdb correctly guesses module name |
| 195 |
# for databases opened with "module" module. |
| 196 |
name = module.__name__ |
| 197 |
setup_test_dir() |
| 198 |
dbm._defaultmod = module |
| 199 |
# Try with empty files first |
| 200 |
with module.open(_fname, 'c'): pass |
| 201 |
for path in fnames: |
| 202 |
self.assertEqual(name, self.dbm.whichdb(path)) |
| 203 |
# Now add a key |
| 204 |
with module.open(_fname, 'w') as f: |
| 205 |
f[b"1"] = b"1" |
| 206 |
# and test that we can find it |
| 207 |
self.assertIn(b"1", f) |
| 208 |
# and read it |
| 209 |
self.assertEqual(f[b"1"], b"1") |
| 210 |
for path in fnames: |
| 211 |
self.assertEqual(name, self.dbm.whichdb(path)) |
| 212 |
|
| 213 |
@unittest.skipUnless(ndbm, reason='Test requires ndbm') |
| 214 |
def test_whichdb_ndbm(self): |
| 215 |
# Issue 17198: check that ndbm which is referenced in whichdb is defined |
| 216 |
with open(_fname + '.db', 'wb') as f: |
| 217 |
f.write(b'spam') |
| 218 |
_bytes_fname = os.fsencode(_fname) |
| 219 |
fnames = [_fname, os_helper.FakePath(_fname), |
| 220 |
_bytes_fname, os_helper.FakePath(_bytes_fname)] |
| 221 |
for path in fnames: |
| 222 |
self.assertIsNone(self.dbm.whichdb(path)) |
| 223 |
|
| 224 |
@unittest.skipUnless(dbm_sqlite3, reason='Test requires dbm.sqlite3') |
| 225 |
def test_whichdb_sqlite3(self): |
| 226 |
# Databases created by dbm.sqlite3 are detected correctly. |
| 227 |
with dbm_sqlite3.open(_fname, "c") as db: |
| 228 |
db["key"] = "value" |
| 229 |
self.assertEqual(self.dbm.whichdb(_fname), "dbm.sqlite3") |
| 230 |
|
| 231 |
@unittest.skipUnless(dbm_sqlite3, reason='Test requires dbm.sqlite3') |
| 232 |
def test_whichdb_sqlite3_existing_db(self): |
| 233 |
# Existing sqlite3 databases are detected correctly. |
| 234 |
sqlite3 = import_helper.import_module("sqlite3") |
| 235 |
try: |
| 236 |
# Create an empty database. |
| 237 |
with sqlite3.connect(_fname) as cx: |
| 238 |
cx.execute("CREATE TABLE dummy(database)") |
| 239 |
cx.commit() |
| 240 |
finally: |
| 241 |
cx.close() |
| 242 |
self.assertEqual(self.dbm.whichdb(_fname), "dbm.sqlite3") |
| 243 |
|
| 244 |
|
| 245 |
def setUp(self): |
| 246 |
self.addCleanup(cleaunup_test_dir) |
| 247 |
setup_test_dir() |
| 248 |
self.dbm = import_helper.import_fresh_module('dbm') |
| 249 |
|
| 250 |
|
| 251 |
for mod in dbm_iterator(): |
| 252 |
assert mod.__name__.startswith('dbm.') |
| 253 |
suffix = mod.__name__[4:] |
| 254 |
testname = f'TestCase_{suffix}' |
| 255 |
globals()[testname] = type(testname, |
| 256 |
(AnyDBMTestCase, unittest.TestCase), |
| 257 |
{'module': mod}) |
| 258 |
|
| 259 |
|
| 260 |
if __name__ == "__main__": |
| 261 |
unittest.main() |