Mercurial > hg
comparison tests/test-manifest.py @ 24225:3e5c4af69808
manifest: split manifestdict into high-level and low-level logic
The low-level logic type (_lazymanifest) matches the behavior of the C
implementation introduced in a5f1bccd. A future patch will use that
when available.
author | Augie Fackler <augie@google.com> |
---|---|
date | Sat, 07 Mar 2015 12:04:39 -0500 |
parents | a5f1bccd2996 |
children | 542c891274b2 |
comparison
equal
deleted
inserted
replaced
24224:d71837d06597 | 24225:3e5c4af69808 |
---|---|
2 import unittest | 2 import unittest |
3 import itertools | 3 import itertools |
4 | 4 |
5 import silenttestrunner | 5 import silenttestrunner |
6 | 6 |
7 from mercurial import parsers | 7 from mercurial import manifest as manifestmod |
8 | 8 |
9 HASH_1 = '1' * 40 | 9 HASH_1 = '1' * 40 |
10 HASH_2 = 'f' * 40 | 10 HASH_2 = 'f' * 40 |
11 HASH_3 = '1234567890abcdef0987654321deadbeef0fcafe' | 11 HASH_3 = '1234567890abcdef0987654321deadbeef0fcafe' |
12 A_SHORT_MANIFEST = ( | 12 A_SHORT_MANIFEST = ( |
36 if not msg: | 36 if not msg: |
37 msg = 'Expected %r in %r' % (thing, container) | 37 msg = 'Expected %r in %r' % (thing, container) |
38 self.assert_(thing in container, msg) | 38 self.assert_(thing in container, msg) |
39 | 39 |
40 def testEmptyManifest(self): | 40 def testEmptyManifest(self): |
41 m = parsers.lazymanifest('') | 41 m = manifestmod._lazymanifest('') |
42 self.assertEqual(0, len(m)) | 42 self.assertEqual(0, len(m)) |
43 self.assertEqual([], list(m)) | 43 self.assertEqual([], list(m)) |
44 | 44 |
45 def testManifest(self): | 45 def testManifest(self): |
46 m = parsers.lazymanifest(A_SHORT_MANIFEST) | 46 m = manifestmod._lazymanifest(A_SHORT_MANIFEST) |
47 want = [ | 47 want = [ |
48 ('bar/baz/qux.py', binascii.unhexlify(HASH_2), 'l'), | 48 ('bar/baz/qux.py', binascii.unhexlify(HASH_2), 'l'), |
49 ('foo', binascii.unhexlify(HASH_1), ''), | 49 ('foo', binascii.unhexlify(HASH_1), ''), |
50 ] | 50 ] |
51 self.assertEqual(len(want), len(m)) | 51 self.assertEqual(len(want), len(m)) |
56 m['bar/baz/qux.py']) | 56 m['bar/baz/qux.py']) |
57 | 57 |
58 def testSetItem(self): | 58 def testSetItem(self): |
59 want = binascii.unhexlify(HASH_1), '' | 59 want = binascii.unhexlify(HASH_1), '' |
60 | 60 |
61 m = parsers.lazymanifest('') | 61 m = manifestmod._lazymanifest('') |
62 m['a'] = want | 62 m['a'] = want |
63 self.assertIn('a', m) | 63 self.assertIn('a', m) |
64 self.assertEqual(want, m['a']) | 64 self.assertEqual(want, m['a']) |
65 self.assertEqual('a\0' + HASH_1 + '\n', m.text()) | 65 self.assertEqual('a\0' + HASH_1 + '\n', m.text()) |
66 | 66 |
67 m = parsers.lazymanifest(A_SHORT_MANIFEST) | 67 m = manifestmod._lazymanifest(A_SHORT_MANIFEST) |
68 m['a'] = want | 68 m['a'] = want |
69 self.assertEqual(want, m['a']) | 69 self.assertEqual(want, m['a']) |
70 self.assertEqual('a\0' + HASH_1 + '\n' + A_SHORT_MANIFEST, | 70 self.assertEqual('a\0' + HASH_1 + '\n' + A_SHORT_MANIFEST, |
71 m.text()) | 71 m.text()) |
72 m2 = m.copy() | 72 m2 = m.copy() |
74 del m2 # make sure we don't double free() anything | 74 del m2 # make sure we don't double free() anything |
75 | 75 |
76 def testCompaction(self): | 76 def testCompaction(self): |
77 unhex = binascii.unhexlify | 77 unhex = binascii.unhexlify |
78 h1, h2 = unhex(HASH_1), unhex(HASH_2) | 78 h1, h2 = unhex(HASH_1), unhex(HASH_2) |
79 m = parsers.lazymanifest(A_SHORT_MANIFEST) | 79 m = manifestmod._lazymanifest(A_SHORT_MANIFEST) |
80 m['alpha'] = h1, '' | 80 m['alpha'] = h1, '' |
81 m['beta'] = h2, '' | 81 m['beta'] = h2, '' |
82 del m['foo'] | 82 del m['foo'] |
83 want = 'alpha\0%s\nbar/baz/qux.py\0%sl\nbeta\0%s\n' % ( | 83 want = 'alpha\0%s\nbar/baz/qux.py\0%sl\nbeta\0%s\n' % ( |
84 HASH_1, HASH_2, HASH_2) | 84 HASH_1, HASH_2, HASH_2) |
89 self.assertRaises(KeyError, lambda : m['foo']) | 89 self.assertRaises(KeyError, lambda : m['foo']) |
90 w = [('alpha', h1, ''), ('bar/baz/qux.py', h2, 'l'), ('beta', h2, '')] | 90 w = [('alpha', h1, ''), ('bar/baz/qux.py', h2, 'l'), ('beta', h2, '')] |
91 self.assertEqual(w, list(m)) | 91 self.assertEqual(w, list(m)) |
92 | 92 |
93 def testSetGetNodeSuffix(self): | 93 def testSetGetNodeSuffix(self): |
94 clean = parsers.lazymanifest(A_SHORT_MANIFEST) | 94 clean = manifestmod._lazymanifest(A_SHORT_MANIFEST) |
95 m = parsers.lazymanifest(A_SHORT_MANIFEST) | 95 m = manifestmod._lazymanifest(A_SHORT_MANIFEST) |
96 h, f = m['foo'] | 96 h, f = m['foo'] |
97 want = h + 'a', f | 97 want = h + 'a', f |
98 # Merge code wants to set 21-byte fake hashes at times | 98 # Merge code wants to set 21-byte fake hashes at times |
99 m['foo'] = want | 99 m['foo'] = want |
100 self.assertEqual(want, m['foo']) | 100 self.assertEqual(want, m['foo']) |
118 # shows up in diff | 118 # shows up in diff |
119 self.assertEqual({'foo': (want, (h, ''))}, m.diff(clean)) | 119 self.assertEqual({'foo': (want, (h, ''))}, m.diff(clean)) |
120 self.assertEqual({'foo': ((h, ''), want)}, clean.diff(m)) | 120 self.assertEqual({'foo': ((h, ''), want)}, clean.diff(m)) |
121 | 121 |
122 def testFilterCopyException(self): | 122 def testFilterCopyException(self): |
123 m = parsers.lazymanifest(A_SHORT_MANIFEST) | 123 m = manifestmod._lazymanifest(A_SHORT_MANIFEST) |
124 def filt(path): | 124 def filt(path): |
125 if path == 'foo': | 125 if path == 'foo': |
126 assert False | 126 assert False |
127 return True | 127 return True |
128 self.assertRaises(AssertionError, m.filtercopy, filt) | 128 self.assertRaises(AssertionError, m.filtercopy, filt) |
129 | 129 |
130 def testRemoveItem(self): | 130 def testRemoveItem(self): |
131 m = parsers.lazymanifest(A_SHORT_MANIFEST) | 131 m = manifestmod._lazymanifest(A_SHORT_MANIFEST) |
132 del m['foo'] | 132 del m['foo'] |
133 self.assertRaises(KeyError, lambda : m['foo']) | 133 self.assertRaises(KeyError, lambda : m['foo']) |
134 self.assertEqual(1, len(m)) | 134 self.assertEqual(1, len(m)) |
135 self.assertEqual(1, len(list(m))) | 135 self.assertEqual(1, len(list(m))) |
136 | 136 |
137 def testManifestDiff(self): | 137 def testManifestDiff(self): |
138 MISSING = (None, '') | 138 MISSING = (None, '') |
139 addl = 'z-only-in-left\0' + HASH_1 + '\n' | 139 addl = 'z-only-in-left\0' + HASH_1 + '\n' |
140 addr = 'z-only-in-right\0' + HASH_2 + 'x\n' | 140 addr = 'z-only-in-right\0' + HASH_2 + 'x\n' |
141 left = parsers.lazymanifest( | 141 left = manifestmod._lazymanifest( |
142 A_SHORT_MANIFEST.replace(HASH_1, HASH_3 + 'x') + addl) | 142 A_SHORT_MANIFEST.replace(HASH_1, HASH_3 + 'x') + addl) |
143 right = parsers.lazymanifest(A_SHORT_MANIFEST + addr) | 143 right = manifestmod._lazymanifest(A_SHORT_MANIFEST + addr) |
144 want = { | 144 want = { |
145 'foo': ((binascii.unhexlify(HASH_3), 'x'), | 145 'foo': ((binascii.unhexlify(HASH_3), 'x'), |
146 (binascii.unhexlify(HASH_1), '')), | 146 (binascii.unhexlify(HASH_1), '')), |
147 'z-only-in-left': ((binascii.unhexlify(HASH_1), ''), MISSING), | 147 'z-only-in-left': ((binascii.unhexlify(HASH_1), ''), MISSING), |
148 'z-only-in-right': (MISSING, (binascii.unhexlify(HASH_2), 'x')), | 148 'z-only-in-right': (MISSING, (binascii.unhexlify(HASH_2), 'x')), |
152 want = { | 152 want = { |
153 'bar/baz/qux.py': (MISSING, (binascii.unhexlify(HASH_2), 'l')), | 153 'bar/baz/qux.py': (MISSING, (binascii.unhexlify(HASH_2), 'l')), |
154 'foo': (MISSING, (binascii.unhexlify(HASH_3), 'x')), | 154 'foo': (MISSING, (binascii.unhexlify(HASH_3), 'x')), |
155 'z-only-in-left': (MISSING, (binascii.unhexlify(HASH_1), '')), | 155 'z-only-in-left': (MISSING, (binascii.unhexlify(HASH_1), '')), |
156 } | 156 } |
157 self.assertEqual(want, parsers.lazymanifest('').diff(left)) | 157 self.assertEqual(want, manifestmod._lazymanifest('').diff(left)) |
158 | 158 |
159 want = { | 159 want = { |
160 'bar/baz/qux.py': ((binascii.unhexlify(HASH_2), 'l'), MISSING), | 160 'bar/baz/qux.py': ((binascii.unhexlify(HASH_2), 'l'), MISSING), |
161 'foo': ((binascii.unhexlify(HASH_3), 'x'), MISSING), | 161 'foo': ((binascii.unhexlify(HASH_3), 'x'), MISSING), |
162 'z-only-in-left': ((binascii.unhexlify(HASH_1), ''), MISSING), | 162 'z-only-in-left': ((binascii.unhexlify(HASH_1), ''), MISSING), |
163 } | 163 } |
164 self.assertEqual(want, left.diff(parsers.lazymanifest(''))) | 164 self.assertEqual(want, left.diff(manifestmod._lazymanifest(''))) |
165 copy = right.copy() | 165 copy = right.copy() |
166 del copy['z-only-in-right'] | 166 del copy['z-only-in-right'] |
167 del right['foo'] | 167 del right['foo'] |
168 want = { | 168 want = { |
169 'foo': (MISSING, (binascii.unhexlify(HASH_1), '')), | 169 'foo': (MISSING, (binascii.unhexlify(HASH_1), '')), |
170 'z-only-in-right': ((binascii.unhexlify(HASH_2), 'x'), MISSING), | 170 'z-only-in-right': ((binascii.unhexlify(HASH_2), 'x'), MISSING), |
171 } | 171 } |
172 self.assertEqual(want, right.diff(copy)) | 172 self.assertEqual(want, right.diff(copy)) |
173 | 173 |
174 short = parsers.lazymanifest(A_SHORT_MANIFEST) | 174 short = manifestmod._lazymanifest(A_SHORT_MANIFEST) |
175 pruned = short.copy() | 175 pruned = short.copy() |
176 del pruned['foo'] | 176 del pruned['foo'] |
177 want = { | 177 want = { |
178 'foo': ((binascii.unhexlify(HASH_1), ''), MISSING), | 178 'foo': ((binascii.unhexlify(HASH_1), ''), MISSING), |
179 } | 179 } |
190 | 190 |
191 def testReversedLines(self): | 191 def testReversedLines(self): |
192 backwards = ''.join( | 192 backwards = ''.join( |
193 l + '\n' for l in reversed(A_SHORT_MANIFEST.split('\n')) if l) | 193 l + '\n' for l in reversed(A_SHORT_MANIFEST.split('\n')) if l) |
194 try: | 194 try: |
195 parsers.lazymanifest(backwards) | 195 manifestmod._lazymanifest(backwards) |
196 self.fail('Should have raised ValueError') | 196 self.fail('Should have raised ValueError') |
197 except ValueError, v: | 197 except ValueError, v: |
198 self.assertIn('Manifest lines not in sorted order.', str(v)) | 198 self.assertIn('Manifest lines not in sorted order.', str(v)) |
199 | 199 |
200 def testNoTerminalNewline(self): | 200 def testNoTerminalNewline(self): |
201 try: | 201 try: |
202 parsers.lazymanifest(A_SHORT_MANIFEST + 'wat') | 202 manifestmod._lazymanifest(A_SHORT_MANIFEST + 'wat') |
203 self.fail('Should have raised ValueError') | 203 self.fail('Should have raised ValueError') |
204 except ValueError, v: | 204 except ValueError, v: |
205 self.assertIn('Manifest did not end in a newline.', str(v)) | 205 self.assertIn('Manifest did not end in a newline.', str(v)) |
206 | 206 |
207 def testNoNewLineAtAll(self): | 207 def testNoNewLineAtAll(self): |
208 try: | 208 try: |
209 parsers.lazymanifest('wat') | 209 manifestmod._lazymanifest('wat') |
210 self.fail('Should have raised ValueError') | 210 self.fail('Should have raised ValueError') |
211 except ValueError, v: | 211 except ValueError, v: |
212 self.assertIn('Manifest did not end in a newline.', str(v)) | 212 self.assertIn('Manifest did not end in a newline.', str(v)) |
213 | 213 |
214 def testHugeManifest(self): | 214 def testHugeManifest(self): |
215 m = parsers.lazymanifest(A_HUGE_MANIFEST) | 215 m = manifestmod._lazymanifest(A_HUGE_MANIFEST) |
216 self.assertEqual(HUGE_MANIFEST_ENTRIES, len(m)) | 216 self.assertEqual(HUGE_MANIFEST_ENTRIES, len(m)) |
217 self.assertEqual(len(m), len(list(m))) | 217 self.assertEqual(len(m), len(list(m))) |
218 | 218 |
219 def testIntersectFiles(self): | |
220 m = manifestmod.manifestdict(A_HUGE_MANIFEST) | |
221 m2 = m.intersectfiles(['file1', 'file200', 'file300']) | |
222 w = ('file1\0%sx\n' | |
223 'file200\0%sl\n' | |
224 'file300\0%s\n') % (HASH_2, HASH_1, HASH_1) | |
225 self.assertEqual(w, m2.text()) | |
219 | 226 |
220 if __name__ == '__main__': | 227 if __name__ == '__main__': |
221 silenttestrunner.main(__name__) | 228 silenttestrunner.main(__name__) |