| 1 |
import unittest |
| 2 |
import dbm |
| 3 |
import shelve |
| 4 |
import pickle |
| 5 |
import os |
| 6 |
|
| 7 |
from test.support import os_helper |
| 8 |
from collections.abc import MutableMapping |
| 9 |
from test.test_dbm import dbm_iterator |
| 10 |
|
| 11 |
def L1(s): |
| 12 |
return s.decode("latin-1") |
| 13 |
|
| 14 |
class byteskeydict(MutableMapping): |
| 15 |
"Mapping that supports bytes keys" |
| 16 |
|
| 17 |
def __init__(self): |
| 18 |
self.d = {} |
| 19 |
|
| 20 |
def __getitem__(self, key): |
| 21 |
return self.d[L1(key)] |
| 22 |
|
| 23 |
def __setitem__(self, key, value): |
| 24 |
self.d[L1(key)] = value |
| 25 |
|
| 26 |
def __delitem__(self, key): |
| 27 |
del self.d[L1(key)] |
| 28 |
|
| 29 |
def __len__(self): |
| 30 |
return len(self.d) |
| 31 |
|
| 32 |
def iterkeys(self): |
| 33 |
for k in self.d.keys(): |
| 34 |
yield k.encode("latin-1") |
| 35 |
|
| 36 |
__iter__ = iterkeys |
| 37 |
|
| 38 |
def keys(self): |
| 39 |
return list(self.iterkeys()) |
| 40 |
|
| 41 |
def copy(self): |
| 42 |
return byteskeydict(self.d) |
| 43 |
|
| 44 |
|
| 45 |
class TestCase(unittest.TestCase): |
| 46 |
dirname = os_helper.TESTFN |
| 47 |
fn = os.path.join(os_helper.TESTFN, "shelftemp.db") |
| 48 |
|
| 49 |
def test_close(self): |
| 50 |
d1 = {} |
| 51 |
s = shelve.Shelf(d1, protocol=2, writeback=False) |
| 52 |
s['key1'] = [1,2,3,4] |
| 53 |
self.assertEqual(s['key1'], [1,2,3,4]) |
| 54 |
self.assertEqual(len(s), 1) |
| 55 |
s.close() |
| 56 |
self.assertRaises(ValueError, len, s) |
| 57 |
try: |
| 58 |
s['key1'] |
| 59 |
except ValueError: |
| 60 |
pass |
| 61 |
else: |
| 62 |
self.fail('Closed shelf should not find a key') |
| 63 |
|
| 64 |
def test_open_template(self, filename=None, protocol=None): |
| 65 |
os.mkdir(self.dirname) |
| 66 |
self.addCleanup(os_helper.rmtree, self.dirname) |
| 67 |
s = shelve.open(filename=filename if filename is not None else self.fn, |
| 68 |
protocol=protocol) |
| 69 |
try: |
| 70 |
s['key1'] = (1,2,3,4) |
| 71 |
self.assertEqual(s['key1'], (1,2,3,4)) |
| 72 |
finally: |
| 73 |
s.close() |
| 74 |
|
| 75 |
def test_ascii_file_shelf(self): |
| 76 |
self.test_open_template(protocol=0) |
| 77 |
|
| 78 |
def test_binary_file_shelf(self): |
| 79 |
self.test_open_template(protocol=1) |
| 80 |
|
| 81 |
def test_proto2_file_shelf(self): |
| 82 |
self.test_open_template(protocol=2) |
| 83 |
|
| 84 |
def test_pathlib_path_file_shelf(self): |
| 85 |
self.test_open_template(filename=os_helper.FakePath(self.fn)) |
| 86 |
|
| 87 |
def test_bytes_path_file_shelf(self): |
| 88 |
self.test_open_template(filename=os.fsencode(self.fn)) |
| 89 |
|
| 90 |
def test_pathlib_bytes_path_file_shelf(self): |
| 91 |
self.test_open_template(filename=os_helper.FakePath(os.fsencode(self.fn))) |
| 92 |
|
| 93 |
def test_in_memory_shelf(self): |
| 94 |
d1 = byteskeydict() |
| 95 |
with shelve.Shelf(d1, protocol=0) as s: |
| 96 |
s['key1'] = (1,2,3,4) |
| 97 |
self.assertEqual(s['key1'], (1,2,3,4)) |
| 98 |
d2 = byteskeydict() |
| 99 |
with shelve.Shelf(d2, protocol=1) as s: |
| 100 |
s['key1'] = (1,2,3,4) |
| 101 |
self.assertEqual(s['key1'], (1,2,3,4)) |
| 102 |
|
| 103 |
self.assertEqual(len(d1), 1) |
| 104 |
self.assertEqual(len(d2), 1) |
| 105 |
self.assertNotEqual(d1.items(), d2.items()) |
| 106 |
|
| 107 |
def test_mutable_entry(self): |
| 108 |
d1 = byteskeydict() |
| 109 |
with shelve.Shelf(d1, protocol=2, writeback=False) as s: |
| 110 |
s['key1'] = [1,2,3,4] |
| 111 |
self.assertEqual(s['key1'], [1,2,3,4]) |
| 112 |
s['key1'].append(5) |
| 113 |
self.assertEqual(s['key1'], [1,2,3,4]) |
| 114 |
|
| 115 |
d2 = byteskeydict() |
| 116 |
with shelve.Shelf(d2, protocol=2, writeback=True) as s: |
| 117 |
s['key1'] = [1,2,3,4] |
| 118 |
self.assertEqual(s['key1'], [1,2,3,4]) |
| 119 |
s['key1'].append(5) |
| 120 |
self.assertEqual(s['key1'], [1,2,3,4,5]) |
| 121 |
|
| 122 |
self.assertEqual(len(d1), 1) |
| 123 |
self.assertEqual(len(d2), 1) |
| 124 |
|
| 125 |
def test_keyencoding(self): |
| 126 |
d = {} |
| 127 |
key = 'Pöp' |
| 128 |
# the default keyencoding is utf-8 |
| 129 |
shelve.Shelf(d)[key] = [1] |
| 130 |
self.assertIn(key.encode('utf-8'), d) |
| 131 |
# but a different one can be given |
| 132 |
shelve.Shelf(d, keyencoding='latin-1')[key] = [1] |
| 133 |
self.assertIn(key.encode('latin-1'), d) |
| 134 |
# with all consequences |
| 135 |
s = shelve.Shelf(d, keyencoding='ascii') |
| 136 |
self.assertRaises(UnicodeEncodeError, s.__setitem__, key, [1]) |
| 137 |
|
| 138 |
def test_writeback_also_writes_immediately(self): |
| 139 |
# Issue 5754 |
| 140 |
d = {} |
| 141 |
key = 'key' |
| 142 |
encodedkey = key.encode('utf-8') |
| 143 |
with shelve.Shelf(d, writeback=True) as s: |
| 144 |
s[key] = [1] |
| 145 |
p1 = d[encodedkey] # Will give a KeyError if backing store not updated |
| 146 |
s['key'].append(2) |
| 147 |
p2 = d[encodedkey] |
| 148 |
self.assertNotEqual(p1, p2) # Write creates new object in store |
| 149 |
|
| 150 |
def test_with(self): |
| 151 |
d1 = {} |
| 152 |
with shelve.Shelf(d1, protocol=2, writeback=False) as s: |
| 153 |
s['key1'] = [1,2,3,4] |
| 154 |
self.assertEqual(s['key1'], [1,2,3,4]) |
| 155 |
self.assertEqual(len(s), 1) |
| 156 |
self.assertRaises(ValueError, len, s) |
| 157 |
try: |
| 158 |
s['key1'] |
| 159 |
except ValueError: |
| 160 |
pass |
| 161 |
else: |
| 162 |
self.fail('Closed shelf should not find a key') |
| 163 |
|
| 164 |
def test_default_protocol(self): |
| 165 |
with shelve.Shelf({}) as s: |
| 166 |
self.assertEqual(s._protocol, pickle.DEFAULT_PROTOCOL) |
| 167 |
|
| 168 |
|
| 169 |
class TestShelveBase: |
| 170 |
type2test = shelve.Shelf |
| 171 |
|
| 172 |
def _reference(self): |
| 173 |
return {"key1":"value1", "key2":2, "key3":(1,2,3)} |
| 174 |
|
| 175 |
|
| 176 |
class TestShelveInMemBase(TestShelveBase): |
| 177 |
def _empty_mapping(self): |
| 178 |
return shelve.Shelf(byteskeydict(), **self._args) |
| 179 |
|
| 180 |
|
| 181 |
class TestShelveFileBase(TestShelveBase): |
| 182 |
counter = 0 |
| 183 |
|
| 184 |
def _empty_mapping(self): |
| 185 |
self.counter += 1 |
| 186 |
x = shelve.open(self.base_path + str(self.counter), **self._args) |
| 187 |
self.addCleanup(x.close) |
| 188 |
return x |
| 189 |
|
| 190 |
def setUp(self): |
| 191 |
dirname = os_helper.TESTFN |
| 192 |
os.mkdir(dirname) |
| 193 |
self.addCleanup(os_helper.rmtree, dirname) |
| 194 |
self.base_path = os.path.join(dirname, "shelftemp.db") |
| 195 |
self.addCleanup(setattr, dbm, '_defaultmod', dbm._defaultmod) |
| 196 |
dbm._defaultmod = self.dbm_mod |
| 197 |
|
| 198 |
|
| 199 |
from test import mapping_tests |
| 200 |
|
| 201 |
for proto in range(pickle.HIGHEST_PROTOCOL + 1): |
| 202 |
bases = (TestShelveInMemBase, mapping_tests.BasicTestMappingProtocol) |
| 203 |
name = f'TestProto{proto}MemShelve' |
| 204 |
globals()[name] = type(name, bases, |
| 205 |
{'_args': {'protocol': proto}}) |
| 206 |
bases = (TestShelveFileBase, mapping_tests.BasicTestMappingProtocol) |
| 207 |
for dbm_mod in dbm_iterator(): |
| 208 |
assert dbm_mod.__name__.startswith('dbm.') |
| 209 |
suffix = dbm_mod.__name__[4:] |
| 210 |
name = f'TestProto{proto}File_{suffix}Shelve' |
| 211 |
globals()[name] = type(name, bases, |
| 212 |
{'dbm_mod': dbm_mod, '_args': {'protocol': proto}}) |
| 213 |
|
| 214 |
|
| 215 |
if __name__ == "__main__": |
| 216 |
unittest.main() |