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__) |