1
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11
# GNU General Public License for more details.
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18
from bzrlib import errors, chk_map, inventory, osutils
19
from bzrlib.inventory import (CHKInventory, Inventory, ROOT_ID, InventoryFile,
20
InventoryDirectory, InventoryEntry, TreeReference)
21
from bzrlib.tests import TestCase, TestCaseWithTransport
24
class TestInventoryEntry(TestCase):
26
def test_file_kind_character(self):
27
file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
28
self.assertEqual(file.kind_character(), '')
30
def test_dir_kind_character(self):
31
dir = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
32
self.assertEqual(dir.kind_character(), '/')
34
def test_link_kind_character(self):
35
dir = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
36
self.assertEqual(dir.kind_character(), '')
38
def test_dir_detect_changes(self):
39
left = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
41
left.executable = True
42
left.symlink_target='foo'
43
right = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
45
right.symlink_target='bar'
46
self.assertEqual((False, False), left.detect_changes(right))
47
self.assertEqual((False, False), right.detect_changes(left))
49
def test_file_detect_changes(self):
50
left = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
52
right = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
54
self.assertEqual((False, False), left.detect_changes(right))
55
self.assertEqual((False, False), right.detect_changes(left))
56
left.executable = True
57
self.assertEqual((False, True), left.detect_changes(right))
58
self.assertEqual((False, True), right.detect_changes(left))
60
self.assertEqual((True, True), left.detect_changes(right))
61
self.assertEqual((True, True), right.detect_changes(left))
63
def test_symlink_detect_changes(self):
64
left = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
66
left.executable = True
67
left.symlink_target='foo'
68
right = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
70
right.symlink_target='foo'
71
self.assertEqual((False, False), left.detect_changes(right))
72
self.assertEqual((False, False), right.detect_changes(left))
73
left.symlink_target = 'different'
74
self.assertEqual((True, False), left.detect_changes(right))
75
self.assertEqual((True, False), right.detect_changes(left))
77
def test_file_has_text(self):
78
file = inventory.InventoryFile('123', 'hello.c', ROOT_ID)
79
self.failUnless(file.has_text())
81
def test_directory_has_text(self):
82
dir = inventory.InventoryDirectory('123', 'hello.c', ROOT_ID)
83
self.failIf(dir.has_text())
85
def test_link_has_text(self):
86
link = inventory.InventoryLink('123', 'hello.c', ROOT_ID)
87
self.failIf(link.has_text())
89
def test_make_entry(self):
90
self.assertIsInstance(inventory.make_entry("file", "name", ROOT_ID),
91
inventory.InventoryFile)
92
self.assertIsInstance(inventory.make_entry("symlink", "name", ROOT_ID),
93
inventory.InventoryLink)
94
self.assertIsInstance(inventory.make_entry("directory", "name", ROOT_ID),
95
inventory.InventoryDirectory)
97
def test_make_entry_non_normalized(self):
98
orig_normalized_filename = osutils.normalized_filename
101
osutils.normalized_filename = osutils._accessible_normalized_filename
102
entry = inventory.make_entry("file", u'a\u030a', ROOT_ID)
103
self.assertEqual(u'\xe5', entry.name)
104
self.assertIsInstance(entry, inventory.InventoryFile)
106
osutils.normalized_filename = osutils._inaccessible_normalized_filename
107
self.assertRaises(errors.InvalidNormalization,
108
inventory.make_entry, 'file', u'a\u030a', ROOT_ID)
110
osutils.normalized_filename = orig_normalized_filename
113
class TestDescribeChanges(TestCase):
115
def test_describe_change(self):
116
# we need to test the following change combinations:
122
# renamed/reparented and modified
123
# change kind (perhaps can't be done yet?)
124
# also, merged in combination with all of these?
125
old_a = InventoryFile('a-id', 'a_file', ROOT_ID)
126
old_a.text_sha1 = '123132'
128
new_a = InventoryFile('a-id', 'a_file', ROOT_ID)
129
new_a.text_sha1 = '123132'
132
self.assertChangeDescription('unchanged', old_a, new_a)
135
new_a.text_sha1 = 'abcabc'
136
self.assertChangeDescription('modified', old_a, new_a)
138
self.assertChangeDescription('added', None, new_a)
139
self.assertChangeDescription('removed', old_a, None)
140
# perhaps a bit questionable but seems like the most reasonable thing...
141
self.assertChangeDescription('unchanged', None, None)
143
# in this case it's both renamed and modified; show a rename and
145
new_a.name = 'newfilename'
146
self.assertChangeDescription('modified and renamed', old_a, new_a)
148
# reparenting is 'renaming'
149
new_a.name = old_a.name
150
new_a.parent_id = 'somedir-id'
151
self.assertChangeDescription('modified and renamed', old_a, new_a)
153
# reset the content values so its not modified
154
new_a.text_size = old_a.text_size
155
new_a.text_sha1 = old_a.text_sha1
156
new_a.name = old_a.name
158
new_a.name = 'newfilename'
159
self.assertChangeDescription('renamed', old_a, new_a)
161
# reparenting is 'renaming'
162
new_a.name = old_a.name
163
new_a.parent_id = 'somedir-id'
164
self.assertChangeDescription('renamed', old_a, new_a)
166
def assertChangeDescription(self, expected_change, old_ie, new_ie):
167
change = InventoryEntry.describe_change(old_ie, new_ie)
168
self.assertEqual(expected_change, change)
171
class TestCHKInventory(TestCaseWithTransport):
173
def get_chk_bytes(self):
174
# The easiest way to get a CHK store is a development5 repository and
175
# then work with the chk_bytes attribute directly.
176
from bzrlib.tests import TestSkipped
177
raise TestSkipped("Cannot execut CHKInventory tests yet.")
178
repo = self.make_repository(".", format="development5")
180
self.addCleanup(repo.unlock)
181
repo.start_write_group()
182
self.addCleanup(repo.abort_write_group)
183
return repo.chk_bytes
185
def read_bytes(self, chk_bytes, key):
186
stream = chk_bytes.get_record_stream([key], 'unordered', True)
187
return stream.next().get_bytes_as("fulltext")
189
def test_deserialise_gives_CHKInventory(self):
191
inv.revision_id = "revid"
192
inv.root.revision = "rootrev"
193
chk_bytes = self.get_chk_bytes()
194
chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
195
bytes = ''.join(chk_inv.to_lines())
196
new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
197
self.assertEqual("revid", new_inv.revision_id)
198
self.assertEqual("directory", new_inv.root.kind)
199
self.assertEqual(inv.root.file_id, new_inv.root.file_id)
200
self.assertEqual(inv.root.parent_id, new_inv.root.parent_id)
201
self.assertEqual(inv.root.name, new_inv.root.name)
202
self.assertEqual("rootrev", new_inv.root.revision)
203
self.assertEqual('plain', new_inv._search_key_name)
205
def test_deserialise_wrong_revid(self):
207
inv.revision_id = "revid"
208
inv.root.revision = "rootrev"
209
chk_bytes = self.get_chk_bytes()
210
chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
211
bytes = ''.join(chk_inv.to_lines())
212
self.assertRaises(ValueError, CHKInventory.deserialise, chk_bytes,
215
def test_captures_rev_root_byid(self):
217
inv.revision_id = "foo"
218
inv.root.revision = "bar"
219
chk_bytes = self.get_chk_bytes()
220
chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
221
lines = chk_inv.to_lines()
224
'revision_id: foo\n',
225
'root_id: TREE_ROOT\n',
226
'parent_id_basename_to_file_id: sha1:eb23f0ad4b07f48e88c76d4c94292be57fb2785f\n',
227
'id_to_entry: sha1:debfe920f1f10e7929260f0534ac9a24d7aabbb4\n',
229
chk_inv = CHKInventory.deserialise(chk_bytes, ''.join(lines), ('foo',))
230
self.assertEqual('plain', chk_inv._search_key_name)
232
def test_captures_parent_id_basename_index(self):
234
inv.revision_id = "foo"
235
inv.root.revision = "bar"
236
chk_bytes = self.get_chk_bytes()
237
chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
238
lines = chk_inv.to_lines()
241
'revision_id: foo\n',
242
'root_id: TREE_ROOT\n',
243
'parent_id_basename_to_file_id: sha1:eb23f0ad4b07f48e88c76d4c94292be57fb2785f\n',
244
'id_to_entry: sha1:debfe920f1f10e7929260f0534ac9a24d7aabbb4\n',
246
chk_inv = CHKInventory.deserialise(chk_bytes, ''.join(lines), ('foo',))
247
self.assertEqual('plain', chk_inv._search_key_name)
249
def test_captures_search_key_name(self):
251
inv.revision_id = "foo"
252
inv.root.revision = "bar"
253
chk_bytes = self.get_chk_bytes()
254
chk_inv = CHKInventory.from_inventory(chk_bytes, inv,
255
search_key_name='hash-16-way')
256
lines = chk_inv.to_lines()
259
'search_key_name: hash-16-way\n',
260
'root_id: TREE_ROOT\n',
261
'parent_id_basename_to_file_id: sha1:eb23f0ad4b07f48e88c76d4c94292be57fb2785f\n',
262
'revision_id: foo\n',
263
'id_to_entry: sha1:debfe920f1f10e7929260f0534ac9a24d7aabbb4\n',
265
chk_inv = CHKInventory.deserialise(chk_bytes, ''.join(lines), ('foo',))
266
self.assertEqual('hash-16-way', chk_inv._search_key_name)
268
def test_directory_children_on_demand(self):
270
inv.revision_id = "revid"
271
inv.root.revision = "rootrev"
272
inv.add(InventoryFile("fileid", "file", inv.root.file_id))
273
inv["fileid"].revision = "filerev"
274
inv["fileid"].executable = True
275
inv["fileid"].text_sha1 = "ffff"
276
inv["fileid"].text_size = 1
277
chk_bytes = self.get_chk_bytes()
278
chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
279
bytes = ''.join(chk_inv.to_lines())
280
new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
281
root_entry = new_inv[inv.root.file_id]
282
self.assertEqual(None, root_entry._children)
283
self.assertEqual(['file'], root_entry.children.keys())
284
file_direct = new_inv["fileid"]
285
file_found = root_entry.children['file']
286
self.assertEqual(file_direct.kind, file_found.kind)
287
self.assertEqual(file_direct.file_id, file_found.file_id)
288
self.assertEqual(file_direct.parent_id, file_found.parent_id)
289
self.assertEqual(file_direct.name, file_found.name)
290
self.assertEqual(file_direct.revision, file_found.revision)
291
self.assertEqual(file_direct.text_sha1, file_found.text_sha1)
292
self.assertEqual(file_direct.text_size, file_found.text_size)
293
self.assertEqual(file_direct.executable, file_found.executable)
295
def test_from_inventory_maximum_size(self):
296
# from_inventory supports the maximum_size parameter.
298
inv.revision_id = "revid"
299
inv.root.revision = "rootrev"
300
chk_bytes = self.get_chk_bytes()
301
chk_inv = CHKInventory.from_inventory(chk_bytes, inv, 120)
302
self.assertEqual(120, chk_inv.id_to_entry._root_node.maximum_size)
304
def test___iter__(self):
306
inv.revision_id = "revid"
307
inv.root.revision = "rootrev"
308
inv.add(InventoryFile("fileid", "file", inv.root.file_id))
309
inv["fileid"].revision = "filerev"
310
inv["fileid"].executable = True
311
inv["fileid"].text_sha1 = "ffff"
312
inv["fileid"].text_size = 1
313
chk_bytes = self.get_chk_bytes()
314
chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
315
bytes = ''.join(chk_inv.to_lines())
316
new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
317
fileids = list(new_inv.__iter__())
319
self.assertEqual([inv.root.file_id, "fileid"], fileids)
321
def test__len__(self):
323
inv.revision_id = "revid"
324
inv.root.revision = "rootrev"
325
inv.add(InventoryFile("fileid", "file", inv.root.file_id))
326
inv["fileid"].revision = "filerev"
327
inv["fileid"].executable = True
328
inv["fileid"].text_sha1 = "ffff"
329
inv["fileid"].text_size = 1
330
chk_bytes = self.get_chk_bytes()
331
chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
332
self.assertEqual(2, len(chk_inv))
334
def test___getitem__(self):
336
inv.revision_id = "revid"
337
inv.root.revision = "rootrev"
338
inv.add(InventoryFile("fileid", "file", inv.root.file_id))
339
inv["fileid"].revision = "filerev"
340
inv["fileid"].executable = True
341
inv["fileid"].text_sha1 = "ffff"
342
inv["fileid"].text_size = 1
343
chk_bytes = self.get_chk_bytes()
344
chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
345
bytes = ''.join(chk_inv.to_lines())
346
new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
347
root_entry = new_inv[inv.root.file_id]
348
file_entry = new_inv["fileid"]
349
self.assertEqual("directory", root_entry.kind)
350
self.assertEqual(inv.root.file_id, root_entry.file_id)
351
self.assertEqual(inv.root.parent_id, root_entry.parent_id)
352
self.assertEqual(inv.root.name, root_entry.name)
353
self.assertEqual("rootrev", root_entry.revision)
354
self.assertEqual("file", file_entry.kind)
355
self.assertEqual("fileid", file_entry.file_id)
356
self.assertEqual(inv.root.file_id, file_entry.parent_id)
357
self.assertEqual("file", file_entry.name)
358
self.assertEqual("filerev", file_entry.revision)
359
self.assertEqual("ffff", file_entry.text_sha1)
360
self.assertEqual(1, file_entry.text_size)
361
self.assertEqual(True, file_entry.executable)
362
self.assertRaises(errors.NoSuchId, new_inv.__getitem__, 'missing')
364
def test_has_id_true(self):
366
inv.revision_id = "revid"
367
inv.root.revision = "rootrev"
368
inv.add(InventoryFile("fileid", "file", inv.root.file_id))
369
inv["fileid"].revision = "filerev"
370
inv["fileid"].executable = True
371
inv["fileid"].text_sha1 = "ffff"
372
inv["fileid"].text_size = 1
373
chk_bytes = self.get_chk_bytes()
374
chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
375
self.assertTrue(chk_inv.has_id('fileid'))
376
self.assertTrue(chk_inv.has_id(inv.root.file_id))
378
def test_has_id_not(self):
380
inv.revision_id = "revid"
381
inv.root.revision = "rootrev"
382
chk_bytes = self.get_chk_bytes()
383
chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
384
self.assertFalse(chk_inv.has_id('fileid'))
386
def test_id2path(self):
388
inv.revision_id = "revid"
389
inv.root.revision = "rootrev"
390
direntry = InventoryDirectory("dirid", "dir", inv.root.file_id)
391
fileentry = InventoryFile("fileid", "file", "dirid")
394
inv["fileid"].revision = "filerev"
395
inv["fileid"].executable = True
396
inv["fileid"].text_sha1 = "ffff"
397
inv["fileid"].text_size = 1
398
inv["dirid"].revision = "filerev"
399
chk_bytes = self.get_chk_bytes()
400
chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
401
bytes = ''.join(chk_inv.to_lines())
402
new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
403
self.assertEqual('', new_inv.id2path(inv.root.file_id))
404
self.assertEqual('dir', new_inv.id2path('dirid'))
405
self.assertEqual('dir/file', new_inv.id2path('fileid'))
407
def test_path2id(self):
409
inv.revision_id = "revid"
410
inv.root.revision = "rootrev"
411
direntry = InventoryDirectory("dirid", "dir", inv.root.file_id)
412
fileentry = InventoryFile("fileid", "file", "dirid")
415
inv["fileid"].revision = "filerev"
416
inv["fileid"].executable = True
417
inv["fileid"].text_sha1 = "ffff"
418
inv["fileid"].text_size = 1
419
inv["dirid"].revision = "filerev"
420
chk_bytes = self.get_chk_bytes()
421
chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
422
bytes = ''.join(chk_inv.to_lines())
423
new_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
424
self.assertEqual(inv.root.file_id, new_inv.path2id(''))
425
self.assertEqual('dirid', new_inv.path2id('dir'))
426
self.assertEqual('fileid', new_inv.path2id('dir/file'))
428
def test_create_by_apply_delta_sets_root(self):
430
inv.revision_id = "revid"
431
chk_bytes = self.get_chk_bytes()
432
base_inv = CHKInventory.from_inventory(chk_bytes, inv)
433
inv.add_path("", "directory", "myrootid", None)
434
inv.revision_id = "expectedid"
435
reference_inv = CHKInventory.from_inventory(chk_bytes, inv)
436
delta = [(None, "", "myrootid", inv.root)]
437
new_inv = base_inv.create_by_apply_delta(delta, "expectedid")
438
self.assertEquals(reference_inv.root, new_inv.root)
440
def test_create_by_apply_delta_empty_add_child(self):
442
inv.revision_id = "revid"
443
inv.root.revision = "rootrev"
444
chk_bytes = self.get_chk_bytes()
445
base_inv = CHKInventory.from_inventory(chk_bytes, inv)
446
a_entry = InventoryFile("A-id", "A", inv.root.file_id)
447
a_entry.revision = "filerev"
448
a_entry.executable = True
449
a_entry.text_sha1 = "ffff"
450
a_entry.text_size = 1
452
inv.revision_id = "expectedid"
453
reference_inv = CHKInventory.from_inventory(chk_bytes, inv)
454
delta = [(None, "A", "A-id", a_entry)]
455
new_inv = base_inv.create_by_apply_delta(delta, "expectedid")
456
# new_inv should be the same as reference_inv.
457
self.assertEqual(reference_inv.revision_id, new_inv.revision_id)
458
self.assertEqual(reference_inv.root_id, new_inv.root_id)
459
self.assertEqual(reference_inv.id_to_entry._root_node._key,
460
new_inv.id_to_entry._root_node._key)
462
def test_create_by_apply_delta_empty_add_child_updates_parent_id(self):
464
inv.revision_id = "revid"
465
inv.root.revision = "rootrev"
466
chk_bytes = self.get_chk_bytes()
467
base_inv = CHKInventory.from_inventory(chk_bytes, inv)
468
a_entry = InventoryFile("A-id", "A", inv.root.file_id)
469
a_entry.revision = "filerev"
470
a_entry.executable = True
471
a_entry.text_sha1 = "ffff"
472
a_entry.text_size = 1
474
inv.revision_id = "expectedid"
475
reference_inv = CHKInventory.from_inventory(chk_bytes, inv)
476
delta = [(None, "A", "A-id", a_entry)]
477
new_inv = base_inv.create_by_apply_delta(delta, "expectedid")
478
# new_inv should be the same as reference_inv.
479
self.assertEqual(reference_inv.revision_id, new_inv.revision_id)
480
self.assertEqual(reference_inv.root_id, new_inv.root_id)
481
self.assertEqual(reference_inv.id_to_entry._root_node._key,
482
new_inv.id_to_entry._root_node._key)
483
self.assertEqual(reference_inv.parent_id_basename_to_file_id._root_node._key,
484
new_inv.parent_id_basename_to_file_id._root_node._key)
486
def test_iter_changes(self):
487
# Low level bootstrapping smoke test; comprehensive generic tests via
488
# InterTree are coming.
490
inv.revision_id = "revid"
491
inv.root.revision = "rootrev"
492
inv.add(InventoryFile("fileid", "file", inv.root.file_id))
493
inv["fileid"].revision = "filerev"
494
inv["fileid"].executable = True
495
inv["fileid"].text_sha1 = "ffff"
496
inv["fileid"].text_size = 1
498
inv2.revision_id = "revid2"
499
inv2.root.revision = "rootrev"
500
inv2.add(InventoryFile("fileid", "file", inv.root.file_id))
501
inv2["fileid"].revision = "filerev2"
502
inv2["fileid"].executable = False
503
inv2["fileid"].text_sha1 = "bbbb"
504
inv2["fileid"].text_size = 2
506
chk_bytes = self.get_chk_bytes()
507
chk_inv = CHKInventory.from_inventory(chk_bytes, inv)
508
bytes = ''.join(chk_inv.to_lines())
509
inv_1 = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
510
chk_inv2 = CHKInventory.from_inventory(chk_bytes, inv2)
511
bytes = ''.join(chk_inv2.to_lines())
512
inv_2 = CHKInventory.deserialise(chk_bytes, bytes, ("revid2",))
513
self.assertEqual([('fileid', (u'file', u'file'), True, (True, True),
514
('TREE_ROOT', 'TREE_ROOT'), (u'file', u'file'), ('file', 'file'),
516
list(inv_1.iter_changes(inv_2)))
518
def test_parent_id_basename_to_file_id_index_enabled(self):
520
inv.revision_id = "revid"
521
inv.root.revision = "rootrev"
522
inv.add(InventoryFile("fileid", "file", inv.root.file_id))
523
inv["fileid"].revision = "filerev"
524
inv["fileid"].executable = True
525
inv["fileid"].text_sha1 = "ffff"
526
inv["fileid"].text_size = 1
528
chk_bytes = self.get_chk_bytes()
529
tmp_inv = CHKInventory.from_inventory(chk_bytes, inv)
530
bytes = ''.join(tmp_inv.to_lines())
531
chk_inv = CHKInventory.deserialise(chk_bytes, bytes, ("revid",))
532
self.assertIsInstance(chk_inv.parent_id_basename_to_file_id, chk_map.CHKMap)
534
{('', ''): 'TREE_ROOT', ('TREE_ROOT', 'file'): 'fileid'},
535
dict(chk_inv.parent_id_basename_to_file_id.iteritems()))
537
def test_file_entry_to_bytes(self):
538
inv = CHKInventory(None)
539
ie = inventory.InventoryFile('file-id', 'filename', 'parent-id')
541
ie.revision = 'file-rev-id'
542
ie.text_sha1 = 'abcdefgh'
544
bytes = inv._entry_to_bytes(ie)
545
self.assertEqual('file: file-id\nparent-id\nfilename\n'
546
'file-rev-id\nabcdefgh\n100\nY', bytes)
547
ie2 = inv._bytes_to_entry(bytes)
548
self.assertEqual(ie, ie2)
549
self.assertIsInstance(ie2.name, unicode)
550
self.assertEqual(('filename', 'file-id', 'file-rev-id'),
551
inv._bytes_to_utf8name_key(bytes))
553
def test_file2_entry_to_bytes(self):
554
inv = CHKInventory(None)
556
ie = inventory.InventoryFile('file-id', u'\u03a9name', 'parent-id')
557
ie.executable = False
558
ie.revision = 'file-rev-id'
559
ie.text_sha1 = '123456'
561
bytes = inv._entry_to_bytes(ie)
562
self.assertEqual('file: file-id\nparent-id\n\xce\xa9name\n'
563
'file-rev-id\n123456\n25\nN', bytes)
564
ie2 = inv._bytes_to_entry(bytes)
565
self.assertEqual(ie, ie2)
566
self.assertIsInstance(ie2.name, unicode)
567
self.assertEqual(('\xce\xa9name', 'file-id', 'file-rev-id'),
568
inv._bytes_to_utf8name_key(bytes))
570
def test_dir_entry_to_bytes(self):
571
inv = CHKInventory(None)
572
ie = inventory.InventoryDirectory('dir-id', 'dirname', 'parent-id')
573
ie.revision = 'dir-rev-id'
574
bytes = inv._entry_to_bytes(ie)
575
self.assertEqual('dir: dir-id\nparent-id\ndirname\ndir-rev-id', bytes)
576
ie2 = inv._bytes_to_entry(bytes)
577
self.assertEqual(ie, ie2)
578
self.assertIsInstance(ie2.name, unicode)
579
self.assertEqual(('dirname', 'dir-id', 'dir-rev-id'),
580
inv._bytes_to_utf8name_key(bytes))
582
def test_dir2_entry_to_bytes(self):
583
inv = CHKInventory(None)
584
ie = inventory.InventoryDirectory('dir-id', u'dir\u03a9name',
586
ie.revision = 'dir-rev-id'
587
bytes = inv._entry_to_bytes(ie)
588
self.assertEqual('dir: dir-id\n\ndir\xce\xa9name\n'
590
ie2 = inv._bytes_to_entry(bytes)
591
self.assertEqual(ie, ie2)
592
self.assertIsInstance(ie2.name, unicode)
593
self.assertIs(ie2.parent_id, None)
594
self.assertEqual(('dir\xce\xa9name', 'dir-id', 'dir-rev-id'),
595
inv._bytes_to_utf8name_key(bytes))
597
def test_symlink_entry_to_bytes(self):
598
inv = CHKInventory(None)
599
ie = inventory.InventoryLink('link-id', 'linkname', 'parent-id')
600
ie.revision = 'link-rev-id'
601
ie.symlink_target = u'target/path'
602
bytes = inv._entry_to_bytes(ie)
603
self.assertEqual('symlink: link-id\nparent-id\nlinkname\n'
604
'link-rev-id\ntarget/path', bytes)
605
ie2 = inv._bytes_to_entry(bytes)
606
self.assertEqual(ie, ie2)
607
self.assertIsInstance(ie2.name, unicode)
608
self.assertIsInstance(ie2.symlink_target, unicode)
609
self.assertEqual(('linkname', 'link-id', 'link-rev-id'),
610
inv._bytes_to_utf8name_key(bytes))
612
def test_symlink2_entry_to_bytes(self):
613
inv = CHKInventory(None)
614
ie = inventory.InventoryLink('link-id', u'link\u03a9name', 'parent-id')
615
ie.revision = 'link-rev-id'
616
ie.symlink_target = u'target/\u03a9path'
617
bytes = inv._entry_to_bytes(ie)
618
self.assertEqual('symlink: link-id\nparent-id\nlink\xce\xa9name\n'
619
'link-rev-id\ntarget/\xce\xa9path', bytes)
620
ie2 = inv._bytes_to_entry(bytes)
621
self.assertEqual(ie, ie2)
622
self.assertIsInstance(ie2.name, unicode)
623
self.assertIsInstance(ie2.symlink_target, unicode)
624
self.assertEqual(('link\xce\xa9name', 'link-id', 'link-rev-id'),
625
inv._bytes_to_utf8name_key(bytes))
627
def test_tree_reference_entry_to_bytes(self):
628
inv = CHKInventory(None)
629
ie = inventory.TreeReference('tree-root-id', u'tree\u03a9name',
631
ie.revision = 'tree-rev-id'
632
ie.reference_revision = 'ref-rev-id'
633
bytes = inv._entry_to_bytes(ie)
634
self.assertEqual('tree: tree-root-id\nparent-id\ntree\xce\xa9name\n'
635
'tree-rev-id\nref-rev-id', bytes)
636
ie2 = inv._bytes_to_entry(bytes)
637
self.assertEqual(ie, ie2)
638
self.assertIsInstance(ie2.name, unicode)
639
self.assertEqual(('tree\xce\xa9name', 'tree-root-id', 'tree-rev-id'),
640
inv._bytes_to_utf8name_key(bytes))
added
removed
bzrlib/tests/test_inv.py
