Guido van Rossum | 2f1064c | 2001-01-18 16:46:52 +0000 | [diff] [blame] | 1 | """Test script for the dumbdbm module |
| 2 | Original by Roger E. Masse |
| 3 | """ |
| 4 | |
Guido van Rossum | 6252e10 | 2007-05-23 20:51:02 +0000 | [diff] [blame] | 5 | import io |
Benjamin Peterson | e3083d3 | 2014-04-26 16:56:52 -0400 | [diff] [blame] | 6 | import operator |
Guido van Rossum | 2f1064c | 2001-01-18 16:46:52 +0000 | [diff] [blame] | 7 | import os |
Serhiy Storchaka | 028ace1 | 2016-12-07 10:56:39 +0200 | [diff] [blame] | 8 | import stat |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 9 | import unittest |
Serhiy Storchaka | 0122ae9 | 2016-07-06 12:21:58 +0300 | [diff] [blame] | 10 | import warnings |
Georg Brandl | 0a7ac7d | 2008-05-26 10:29:35 +0000 | [diff] [blame] | 11 | import dbm.dumb as dumbdbm |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 12 | from test import support |
Benjamin Peterson | e3083d3 | 2014-04-26 16:56:52 -0400 | [diff] [blame] | 13 | from functools import partial |
Guido van Rossum | 2f1064c | 2001-01-18 16:46:52 +0000 | [diff] [blame] | 14 | |
Benjamin Peterson | ee8712c | 2008-05-20 21:35:26 +0000 | [diff] [blame] | 15 | _fname = support.TESTFN |
Tim Peters | d9fbf35 | 2002-01-30 07:32:53 +0000 | [diff] [blame] | 16 | |
| 17 | def _delete_files(): |
| 18 | for ext in [".dir", ".dat", ".bak"]: |
| 19 | try: |
| 20 | os.unlink(_fname + ext) |
| 21 | except OSError: |
| 22 | pass |
| 23 | |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 24 | class DumbDBMTestCase(unittest.TestCase): |
Brett Cannon | 58425d3 | 2008-11-21 00:17:53 +0000 | [diff] [blame] | 25 | _dict = {b'0': b'', |
| 26 | b'a': b'Python:', |
| 27 | b'b': b'Programming', |
| 28 | b'c': b'the', |
| 29 | b'd': b'way', |
| 30 | b'f': b'Guido', |
| 31 | b'g': b'intended', |
| 32 | '\u00fc'.encode('utf-8') : b'!', |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 33 | } |
| 34 | |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 35 | def test_dumbdbm_creation(self): |
Tim Peters | d9fbf35 | 2002-01-30 07:32:53 +0000 | [diff] [blame] | 36 | f = dumbdbm.open(_fname, 'c') |
Brett Cannon | c1b22a0 | 2007-02-22 05:04:32 +0000 | [diff] [blame] | 37 | self.assertEqual(list(f.keys()), []) |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 38 | for key in self._dict: |
Brett Cannon | 58425d3 | 2008-11-21 00:17:53 +0000 | [diff] [blame] | 39 | f[key] = self._dict[key] |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 40 | self.read_helper(f) |
| 41 | f.close() |
| 42 | |
Serhiy Storchaka | 4376763 | 2013-11-03 21:31:38 +0200 | [diff] [blame] | 43 | @unittest.skipUnless(hasattr(os, 'umask'), 'test needs os.umask()') |
| 44 | @unittest.skipUnless(hasattr(os, 'chmod'), 'test needs os.chmod()') |
Thomas Wouters | 902d6eb | 2007-01-09 23:18:33 +0000 | [diff] [blame] | 45 | def test_dumbdbm_creation_mode(self): |
Thomas Wouters | 902d6eb | 2007-01-09 23:18:33 +0000 | [diff] [blame] | 46 | try: |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 47 | old_umask = os.umask(0o002) |
| 48 | f = dumbdbm.open(_fname, 'c', 0o637) |
Thomas Wouters | 902d6eb | 2007-01-09 23:18:33 +0000 | [diff] [blame] | 49 | f.close() |
| 50 | finally: |
| 51 | os.umask(old_umask) |
Thomas Wouters | 9fe394c | 2007-02-05 01:24:16 +0000 | [diff] [blame] | 52 | |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 53 | expected_mode = 0o635 |
Thomas Wouters | b213704 | 2007-02-01 18:02:27 +0000 | [diff] [blame] | 54 | if os.name != 'posix': |
| 55 | # Windows only supports setting the read-only attribute. |
| 56 | # This shouldn't fail, but doesn't work like Unix either. |
Guido van Rossum | cd16bf6 | 2007-06-13 18:07:49 +0000 | [diff] [blame] | 57 | expected_mode = 0o666 |
Thomas Wouters | b213704 | 2007-02-01 18:02:27 +0000 | [diff] [blame] | 58 | |
Thomas Wouters | 902d6eb | 2007-01-09 23:18:33 +0000 | [diff] [blame] | 59 | import stat |
| 60 | st = os.stat(_fname + '.dat') |
Thomas Wouters | b213704 | 2007-02-01 18:02:27 +0000 | [diff] [blame] | 61 | self.assertEqual(stat.S_IMODE(st.st_mode), expected_mode) |
Thomas Wouters | 902d6eb | 2007-01-09 23:18:33 +0000 | [diff] [blame] | 62 | st = os.stat(_fname + '.dir') |
Thomas Wouters | b213704 | 2007-02-01 18:02:27 +0000 | [diff] [blame] | 63 | self.assertEqual(stat.S_IMODE(st.st_mode), expected_mode) |
Thomas Wouters | 9fe394c | 2007-02-05 01:24:16 +0000 | [diff] [blame] | 64 | |
Tim Peters | 7a6c733 | 2003-07-13 17:21:10 +0000 | [diff] [blame] | 65 | def test_close_twice(self): |
| 66 | f = dumbdbm.open(_fname) |
Martin v. Löwis | e656869 | 2007-08-07 05:37:39 +0000 | [diff] [blame] | 67 | f[b'a'] = b'b' |
| 68 | self.assertEqual(f[b'a'], b'b') |
Tim Peters | 7a6c733 | 2003-07-13 17:21:10 +0000 | [diff] [blame] | 69 | f.close() |
| 70 | f.close() |
| 71 | |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 72 | def test_dumbdbm_modification(self): |
Skip Montanaro | c08fe82 | 2002-03-17 23:03:42 +0000 | [diff] [blame] | 73 | self.init_db() |
Tim Peters | d9fbf35 | 2002-01-30 07:32:53 +0000 | [diff] [blame] | 74 | f = dumbdbm.open(_fname, 'w') |
Brett Cannon | 58425d3 | 2008-11-21 00:17:53 +0000 | [diff] [blame] | 75 | self._dict[b'g'] = f[b'g'] = b"indented" |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 76 | self.read_helper(f) |
| 77 | f.close() |
| 78 | |
| 79 | def test_dumbdbm_read(self): |
Skip Montanaro | c08fe82 | 2002-03-17 23:03:42 +0000 | [diff] [blame] | 80 | self.init_db() |
Tim Peters | d9fbf35 | 2002-01-30 07:32:53 +0000 | [diff] [blame] | 81 | f = dumbdbm.open(_fname, 'r') |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 82 | self.read_helper(f) |
Serhiy Storchaka | 0122ae9 | 2016-07-06 12:21:58 +0300 | [diff] [blame] | 83 | with self.assertWarnsRegex(DeprecationWarning, |
| 84 | 'The database is opened for reading only'): |
| 85 | f[b'g'] = b'x' |
| 86 | with self.assertWarnsRegex(DeprecationWarning, |
| 87 | 'The database is opened for reading only'): |
| 88 | del f[b'a'] |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 89 | f.close() |
| 90 | |
| 91 | def test_dumbdbm_keys(self): |
Skip Montanaro | c08fe82 | 2002-03-17 23:03:42 +0000 | [diff] [blame] | 92 | self.init_db() |
Tim Peters | d9fbf35 | 2002-01-30 07:32:53 +0000 | [diff] [blame] | 93 | f = dumbdbm.open(_fname) |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 94 | keys = self.keys_helper(f) |
| 95 | f.close() |
| 96 | |
Gregory P. Smith | 178fefb | 2007-08-24 21:59:45 +0000 | [diff] [blame] | 97 | def test_write_contains(self): |
| 98 | f = dumbdbm.open(_fname) |
| 99 | f[b'1'] = b'hello' |
Benjamin Peterson | 577473f | 2010-01-19 00:09:57 +0000 | [diff] [blame] | 100 | self.assertIn(b'1', f) |
Gregory P. Smith | 178fefb | 2007-08-24 21:59:45 +0000 | [diff] [blame] | 101 | f.close() |
| 102 | |
Skip Montanaro | c08fe82 | 2002-03-17 23:03:42 +0000 | [diff] [blame] | 103 | def test_write_write_read(self): |
| 104 | # test for bug #482460 |
| 105 | f = dumbdbm.open(_fname) |
Martin v. Löwis | e656869 | 2007-08-07 05:37:39 +0000 | [diff] [blame] | 106 | f[b'1'] = b'hello' |
| 107 | f[b'1'] = b'hello2' |
Skip Montanaro | c08fe82 | 2002-03-17 23:03:42 +0000 | [diff] [blame] | 108 | f.close() |
| 109 | f = dumbdbm.open(_fname) |
Guido van Rossum | 7b4beea | 2007-08-28 00:09:54 +0000 | [diff] [blame] | 110 | self.assertEqual(f[b'1'], b'hello2') |
Skip Montanaro | c08fe82 | 2002-03-17 23:03:42 +0000 | [diff] [blame] | 111 | f.close() |
| 112 | |
Brett Cannon | 58425d3 | 2008-11-21 00:17:53 +0000 | [diff] [blame] | 113 | def test_str_read(self): |
| 114 | self.init_db() |
| 115 | f = dumbdbm.open(_fname, 'r') |
| 116 | self.assertEqual(f['\u00fc'], self._dict['\u00fc'.encode('utf-8')]) |
| 117 | |
| 118 | def test_str_write_contains(self): |
| 119 | self.init_db() |
| 120 | f = dumbdbm.open(_fname) |
| 121 | f['\u00fc'] = b'!' |
Brett Cannon | 7317c1e | 2008-11-25 19:19:17 +0000 | [diff] [blame] | 122 | f['1'] = 'a' |
Brett Cannon | 58425d3 | 2008-11-21 00:17:53 +0000 | [diff] [blame] | 123 | f.close() |
| 124 | f = dumbdbm.open(_fname, 'r') |
Benjamin Peterson | 577473f | 2010-01-19 00:09:57 +0000 | [diff] [blame] | 125 | self.assertIn('\u00fc', f) |
Brett Cannon | 58425d3 | 2008-11-21 00:17:53 +0000 | [diff] [blame] | 126 | self.assertEqual(f['\u00fc'.encode('utf-8')], |
| 127 | self._dict['\u00fc'.encode('utf-8')]) |
Brett Cannon | 7317c1e | 2008-11-25 19:19:17 +0000 | [diff] [blame] | 128 | self.assertEqual(f[b'1'], b'a') |
Brett Cannon | 58425d3 | 2008-11-21 00:17:53 +0000 | [diff] [blame] | 129 | |
Andrew M. Kuchling | ecdad85 | 2005-06-07 19:36:10 +0000 | [diff] [blame] | 130 | def test_line_endings(self): |
| 131 | # test for bug #1172763: dumbdbm would die if the line endings |
| 132 | # weren't what was expected. |
| 133 | f = dumbdbm.open(_fname) |
Martin v. Löwis | e656869 | 2007-08-07 05:37:39 +0000 | [diff] [blame] | 134 | f[b'1'] = b'hello' |
| 135 | f[b'2'] = b'hello2' |
Andrew M. Kuchling | ecdad85 | 2005-06-07 19:36:10 +0000 | [diff] [blame] | 136 | f.close() |
| 137 | |
Christian Heimes | 9289bfc | 2007-10-31 19:40:17 +0000 | [diff] [blame] | 138 | # Mangle the file by changing the line separator to Windows or Unix |
Brett Cannon | c0eee31 | 2010-10-29 22:49:14 +0000 | [diff] [blame] | 139 | with io.open(_fname + '.dir', 'rb') as file: |
| 140 | data = file.read() |
Guido van Rossum | 98297ee | 2007-11-06 21:34:58 +0000 | [diff] [blame] | 141 | if os.linesep == '\n': |
Christian Heimes | 9289bfc | 2007-10-31 19:40:17 +0000 | [diff] [blame] | 142 | data = data.replace(b'\n', b'\r\n') |
| 143 | else: |
| 144 | data = data.replace(b'\r\n', b'\n') |
Brett Cannon | c0eee31 | 2010-10-29 22:49:14 +0000 | [diff] [blame] | 145 | with io.open(_fname + '.dir', 'wb') as file: |
| 146 | file.write(data) |
Anthony Baxter | 95a2a4e | 2005-06-08 04:35:50 +0000 | [diff] [blame] | 147 | |
Andrew M. Kuchling | ecdad85 | 2005-06-07 19:36:10 +0000 | [diff] [blame] | 148 | f = dumbdbm.open(_fname) |
Martin v. Löwis | e656869 | 2007-08-07 05:37:39 +0000 | [diff] [blame] | 149 | self.assertEqual(f[b'1'], b'hello') |
| 150 | self.assertEqual(f[b'2'], b'hello2') |
Anthony Baxter | 95a2a4e | 2005-06-08 04:35:50 +0000 | [diff] [blame] | 151 | |
| 152 | |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 153 | def read_helper(self, f): |
| 154 | keys = self.keys_helper(f) |
| 155 | for key in self._dict: |
Brett Cannon | 58425d3 | 2008-11-21 00:17:53 +0000 | [diff] [blame] | 156 | self.assertEqual(self._dict[key], f[key]) |
Tim Peters | 8876848 | 2001-11-13 21:51:26 +0000 | [diff] [blame] | 157 | |
Skip Montanaro | c08fe82 | 2002-03-17 23:03:42 +0000 | [diff] [blame] | 158 | def init_db(self): |
Serhiy Storchaka | 0122ae9 | 2016-07-06 12:21:58 +0300 | [diff] [blame] | 159 | f = dumbdbm.open(_fname, 'n') |
Skip Montanaro | c08fe82 | 2002-03-17 23:03:42 +0000 | [diff] [blame] | 160 | for k in self._dict: |
Brett Cannon | 58425d3 | 2008-11-21 00:17:53 +0000 | [diff] [blame] | 161 | f[k] = self._dict[k] |
Skip Montanaro | c08fe82 | 2002-03-17 23:03:42 +0000 | [diff] [blame] | 162 | f.close() |
| 163 | |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 164 | def keys_helper(self, f): |
Brett Cannon | 58425d3 | 2008-11-21 00:17:53 +0000 | [diff] [blame] | 165 | keys = sorted(f.keys()) |
Brett Cannon | c1b22a0 | 2007-02-22 05:04:32 +0000 | [diff] [blame] | 166 | dkeys = sorted(self._dict.keys()) |
Skip Montanaro | c08fe82 | 2002-03-17 23:03:42 +0000 | [diff] [blame] | 167 | self.assertEqual(keys, dkeys) |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 168 | return keys |
| 169 | |
Tim Peters | 663d1b6 | 2003-07-11 04:09:09 +0000 | [diff] [blame] | 170 | # Perform randomized operations. This doesn't make assumptions about |
| 171 | # what *might* fail. |
| 172 | def test_random(self): |
| 173 | import random |
| 174 | d = {} # mirror the database |
| 175 | for dummy in range(5): |
| 176 | f = dumbdbm.open(_fname) |
| 177 | for dummy in range(100): |
| 178 | k = random.choice('abcdefghijklm') |
| 179 | if random.random() < 0.2: |
| 180 | if k in d: |
| 181 | del d[k] |
Brett Cannon | 58425d3 | 2008-11-21 00:17:53 +0000 | [diff] [blame] | 182 | del f[k] |
Tim Peters | 663d1b6 | 2003-07-11 04:09:09 +0000 | [diff] [blame] | 183 | else: |
Guido van Rossum | 6252e10 | 2007-05-23 20:51:02 +0000 | [diff] [blame] | 184 | v = random.choice((b'a', b'b', b'c')) * random.randrange(10000) |
Tim Peters | 663d1b6 | 2003-07-11 04:09:09 +0000 | [diff] [blame] | 185 | d[k] = v |
Brett Cannon | 58425d3 | 2008-11-21 00:17:53 +0000 | [diff] [blame] | 186 | f[k] = v |
| 187 | self.assertEqual(f[k], v) |
Tim Peters | 663d1b6 | 2003-07-11 04:09:09 +0000 | [diff] [blame] | 188 | f.close() |
| 189 | |
| 190 | f = dumbdbm.open(_fname) |
Guido van Rossum | 7b4beea | 2007-08-28 00:09:54 +0000 | [diff] [blame] | 191 | expected = sorted((k.encode("latin-1"), v) for k, v in d.items()) |
Brett Cannon | c1b22a0 | 2007-02-22 05:04:32 +0000 | [diff] [blame] | 192 | got = sorted(f.items()) |
Tim Peters | 663d1b6 | 2003-07-11 04:09:09 +0000 | [diff] [blame] | 193 | self.assertEqual(expected, got) |
| 194 | f.close() |
| 195 | |
Nick Coghlan | c610aba | 2013-11-17 15:59:51 +1000 | [diff] [blame] | 196 | def test_context_manager(self): |
| 197 | with dumbdbm.open(_fname, 'c') as db: |
| 198 | db["dumbdbm context manager"] = "context manager" |
| 199 | |
| 200 | with dumbdbm.open(_fname, 'r') as db: |
| 201 | self.assertEqual(list(db.keys()), [b"dumbdbm context manager"]) |
| 202 | |
Benjamin Peterson | e3083d3 | 2014-04-26 16:56:52 -0400 | [diff] [blame] | 203 | with self.assertRaises(dumbdbm.error): |
Nick Coghlan | c610aba | 2013-11-17 15:59:51 +1000 | [diff] [blame] | 204 | db.keys() |
| 205 | |
Benjamin Peterson | e3083d3 | 2014-04-26 16:56:52 -0400 | [diff] [blame] | 206 | def test_check_closed(self): |
| 207 | f = dumbdbm.open(_fname, 'c') |
| 208 | f.close() |
| 209 | |
| 210 | for meth in (partial(operator.delitem, f), |
| 211 | partial(operator.setitem, f, 'b'), |
| 212 | partial(operator.getitem, f), |
| 213 | partial(operator.contains, f)): |
| 214 | with self.assertRaises(dumbdbm.error) as cm: |
| 215 | meth('test') |
| 216 | self.assertEqual(str(cm.exception), |
| 217 | "DBM object has already been closed") |
| 218 | |
| 219 | for meth in (operator.methodcaller('keys'), |
| 220 | operator.methodcaller('iterkeys'), |
| 221 | operator.methodcaller('items'), |
| 222 | len): |
| 223 | with self.assertRaises(dumbdbm.error) as cm: |
| 224 | meth(f) |
| 225 | self.assertEqual(str(cm.exception), |
| 226 | "DBM object has already been closed") |
| 227 | |
Serhiy Storchaka | b398d33 | 2014-06-10 21:16:00 +0300 | [diff] [blame] | 228 | def test_create_new(self): |
| 229 | with dumbdbm.open(_fname, 'n') as f: |
| 230 | for k in self._dict: |
| 231 | f[k] = self._dict[k] |
| 232 | |
| 233 | with dumbdbm.open(_fname, 'n') as f: |
| 234 | self.assertEqual(f.keys(), []) |
| 235 | |
Serhiy Storchaka | 74eb8b2 | 2015-02-16 00:30:43 +0200 | [diff] [blame] | 236 | def test_eval(self): |
| 237 | with open(_fname + '.dir', 'w') as stream: |
| 238 | stream.write("str(print('Hacked!')), 0\n") |
| 239 | with support.captured_stdout() as stdout: |
| 240 | with self.assertRaises(ValueError): |
| 241 | with dumbdbm.open(_fname) as f: |
| 242 | pass |
| 243 | self.assertEqual(stdout.getvalue(), '') |
| 244 | |
Serhiy Storchaka | 0122ae9 | 2016-07-06 12:21:58 +0300 | [diff] [blame] | 245 | def test_warn_on_ignored_flags(self): |
| 246 | for value in ('r', 'w'): |
| 247 | _delete_files() |
| 248 | with self.assertWarnsRegex(DeprecationWarning, |
| 249 | "The database file is missing, the " |
| 250 | "semantics of the 'c' flag will " |
| 251 | "be used."): |
| 252 | f = dumbdbm.open(_fname, value) |
| 253 | f.close() |
| 254 | |
| 255 | def test_invalid_flag(self): |
| 256 | for flag in ('x', 'rf', None): |
| 257 | with self.assertWarnsRegex(DeprecationWarning, |
| 258 | "Flag must be one of " |
| 259 | "'r', 'w', 'c', or 'n'"): |
| 260 | f = dumbdbm.open(_fname, flag) |
| 261 | f.close() |
| 262 | |
Serhiy Storchaka | 028ace1 | 2016-12-07 10:56:39 +0200 | [diff] [blame] | 263 | @unittest.skipUnless(hasattr(os, 'chmod'), 'test needs os.chmod()') |
| 264 | def test_readonly_files(self): |
| 265 | with support.temp_dir() as dir: |
| 266 | fname = os.path.join(dir, 'db') |
| 267 | with dumbdbm.open(fname, 'n') as f: |
| 268 | self.assertEqual(list(f.keys()), []) |
| 269 | for key in self._dict: |
| 270 | f[key] = self._dict[key] |
| 271 | os.chmod(fname + ".dir", stat.S_IRUSR) |
| 272 | os.chmod(fname + ".dat", stat.S_IRUSR) |
| 273 | os.chmod(dir, stat.S_IRUSR|stat.S_IXUSR) |
| 274 | with dumbdbm.open(fname, 'r') as f: |
| 275 | self.assertEqual(sorted(f.keys()), sorted(self._dict)) |
| 276 | f.close() # don't write |
| 277 | |
Skip Montanaro | c08fe82 | 2002-03-17 23:03:42 +0000 | [diff] [blame] | 278 | def tearDown(self): |
| 279 | _delete_files() |
| 280 | |
| 281 | def setUp(self): |
| 282 | _delete_files() |
| 283 | |
Barry Warsaw | 3ca656f | 2001-11-13 20:16:52 +0000 | [diff] [blame] | 284 | |
| 285 | if __name__ == "__main__": |
Ezio Melotti | f79493b | 2013-03-01 11:23:28 +0200 | [diff] [blame] | 286 | unittest.main() |