Debian Codegraph @

Lib/test/test_dbm.py

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