1
# Copyright (C) 2006-2011 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
17
"""Tests of the dirstate functionality being built for WorkingTreeFormat4."""
29
revision as _mod_revision,
34
from bzrlib.transport import memory
35
from bzrlib.tests import test_osutils
36
from bzrlib.tests.scenarios import load_tests_apply_scenarios
41
# general checks for NOT_IN_MEMORY error conditions.
42
# set_path_id on a NOT_IN_MEMORY dirstate
43
# set_path_id unicode support
44
# set_path_id setting id of a path not root
45
# set_path_id setting id when there are parents without the id in the parents
46
# set_path_id setting id when there are parents with the id in the parents
47
# set_path_id setting id when state is not in memory
48
# set_path_id setting id when state is in memory unmodified
49
# set_path_id setting id when state is in memory modified
52
load_tests = load_tests_apply_scenarios
55
class TestCaseWithDirState(tests.TestCaseWithTransport):
56
"""Helper functions for creating DirState objects with various content."""
58
scenarios = test_osutils.dir_reader_scenarios()
61
_dir_reader_class = None
62
_native_to_unicode = None # Not used yet
65
tests.TestCaseWithTransport.setUp(self)
67
self.overrideAttr(osutils,
68
'_selected_dir_reader', self._dir_reader_class())
70
def create_empty_dirstate(self):
71
"""Return a locked but empty dirstate"""
72
state = dirstate.DirState.initialize('dirstate')
75
def create_dirstate_with_root(self):
76
"""Return a write-locked state with a single root entry."""
77
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
78
root_entry_direntry = ('', '', 'a-root-value'), [
79
('d', '', 0, False, packed_stat),
82
dirblocks.append(('', [root_entry_direntry]))
83
dirblocks.append(('', []))
84
state = self.create_empty_dirstate()
86
state._set_data([], dirblocks)
93
def create_dirstate_with_root_and_subdir(self):
94
"""Return a locked DirState with a root and a subdir"""
95
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
96
subdir_entry = ('', 'subdir', 'subdir-id'), [
97
('d', '', 0, False, packed_stat),
99
state = self.create_dirstate_with_root()
101
dirblocks = list(state._dirblocks)
102
dirblocks[1][1].append(subdir_entry)
103
state._set_data([], dirblocks)
109
def create_complex_dirstate(self):
110
"""This dirstate contains multiple files and directories.
120
b/h\xc3\xa5 h-\xc3\xa5-file #This is u'\xe5' encoded into utf-8
122
Notice that a/e is an empty directory.
124
:return: The dirstate, still write-locked.
126
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
127
null_sha = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
128
root_entry = ('', '', 'a-root-value'), [
129
('d', '', 0, False, packed_stat),
131
a_entry = ('', 'a', 'a-dir'), [
132
('d', '', 0, False, packed_stat),
134
b_entry = ('', 'b', 'b-dir'), [
135
('d', '', 0, False, packed_stat),
137
c_entry = ('', 'c', 'c-file'), [
138
('f', null_sha, 10, False, packed_stat),
140
d_entry = ('', 'd', 'd-file'), [
141
('f', null_sha, 20, False, packed_stat),
143
e_entry = ('a', 'e', 'e-dir'), [
144
('d', '', 0, False, packed_stat),
146
f_entry = ('a', 'f', 'f-file'), [
147
('f', null_sha, 30, False, packed_stat),
149
g_entry = ('b', 'g', 'g-file'), [
150
('f', null_sha, 30, False, packed_stat),
152
h_entry = ('b', 'h\xc3\xa5', 'h-\xc3\xa5-file'), [
153
('f', null_sha, 40, False, packed_stat),
156
dirblocks.append(('', [root_entry]))
157
dirblocks.append(('', [a_entry, b_entry, c_entry, d_entry]))
158
dirblocks.append(('a', [e_entry, f_entry]))
159
dirblocks.append(('b', [g_entry, h_entry]))
160
state = dirstate.DirState.initialize('dirstate')
163
state._set_data([], dirblocks)
169
def check_state_with_reopen(self, expected_result, state):
170
"""Check that state has current state expected_result.
172
This will check the current state, open the file anew and check it
174
This function expects the current state to be locked for writing, and
175
will unlock it before re-opening.
176
This is required because we can't open a lock_read() while something
177
else has a lock_write().
178
write => mutually exclusive lock
181
# The state should already be write locked, since we just had to do
182
# some operation to get here.
183
self.assertTrue(state._lock_token is not None)
185
self.assertEqual(expected_result[0], state.get_parent_ids())
186
# there should be no ghosts in this tree.
187
self.assertEqual([], state.get_ghosts())
188
# there should be one fileid in this tree - the root of the tree.
189
self.assertEqual(expected_result[1], list(state._iter_entries()))
194
state = dirstate.DirState.on_file('dirstate')
197
self.assertEqual(expected_result[1], list(state._iter_entries()))
201
def create_basic_dirstate(self):
202
"""Create a dirstate with a few files and directories.
212
tree = self.make_branch_and_tree('tree')
213
paths = ['a', 'b/', 'b/c', 'b/d/', 'b/d/e', 'b-c', 'f']
214
file_ids = ['a-id', 'b-id', 'c-id', 'd-id', 'e-id', 'b-c-id', 'f-id']
215
self.build_tree(['tree/' + p for p in paths])
216
tree.set_root_id('TREE_ROOT')
217
tree.add([p.rstrip('/') for p in paths], file_ids)
218
tree.commit('initial', rev_id='rev-1')
219
revision_id = 'rev-1'
220
# a_packed_stat = dirstate.pack_stat(os.stat('tree/a'))
221
t = self.get_transport('tree')
222
a_text = t.get_bytes('a')
223
a_sha = osutils.sha_string(a_text)
225
# b_packed_stat = dirstate.pack_stat(os.stat('tree/b'))
226
# c_packed_stat = dirstate.pack_stat(os.stat('tree/b/c'))
227
c_text = t.get_bytes('b/c')
228
c_sha = osutils.sha_string(c_text)
230
# d_packed_stat = dirstate.pack_stat(os.stat('tree/b/d'))
231
# e_packed_stat = dirstate.pack_stat(os.stat('tree/b/d/e'))
232
e_text = t.get_bytes('b/d/e')
233
e_sha = osutils.sha_string(e_text)
235
b_c_text = t.get_bytes('b-c')
236
b_c_sha = osutils.sha_string(b_c_text)
237
b_c_len = len(b_c_text)
238
# f_packed_stat = dirstate.pack_stat(os.stat('tree/f'))
239
f_text = t.get_bytes('f')
240
f_sha = osutils.sha_string(f_text)
242
null_stat = dirstate.DirState.NULLSTAT
244
'':(('', '', 'TREE_ROOT'), [
245
('d', '', 0, False, null_stat),
246
('d', '', 0, False, revision_id),
248
'a':(('', 'a', 'a-id'), [
249
('f', '', 0, False, null_stat),
250
('f', a_sha, a_len, False, revision_id),
252
'b':(('', 'b', 'b-id'), [
253
('d', '', 0, False, null_stat),
254
('d', '', 0, False, revision_id),
256
'b/c':(('b', 'c', 'c-id'), [
257
('f', '', 0, False, null_stat),
258
('f', c_sha, c_len, False, revision_id),
260
'b/d':(('b', 'd', 'd-id'), [
261
('d', '', 0, False, null_stat),
262
('d', '', 0, False, revision_id),
264
'b/d/e':(('b/d', 'e', 'e-id'), [
265
('f', '', 0, False, null_stat),
266
('f', e_sha, e_len, False, revision_id),
268
'b-c':(('', 'b-c', 'b-c-id'), [
269
('f', '', 0, False, null_stat),
270
('f', b_c_sha, b_c_len, False, revision_id),
272
'f':(('', 'f', 'f-id'), [
273
('f', '', 0, False, null_stat),
274
('f', f_sha, f_len, False, revision_id),
277
state = dirstate.DirState.from_tree(tree, 'dirstate')
282
# Use a different object, to make sure nothing is pre-cached in memory.
283
state = dirstate.DirState.on_file('dirstate')
285
self.addCleanup(state.unlock)
286
self.assertEqual(dirstate.DirState.NOT_IN_MEMORY,
287
state._dirblock_state)
288
# This is code is only really tested if we actually have to make more
289
# than one read, so set the page size to something smaller.
290
# We want it to contain about 2.2 records, so that we have a couple
291
# records that we can read per attempt
292
state._bisect_page_size = 200
293
return tree, state, expected
295
def create_duplicated_dirstate(self):
296
"""Create a dirstate with a deleted and added entries.
298
This grabs a basic_dirstate, and then removes and re adds every entry
301
tree, state, expected = self.create_basic_dirstate()
302
# Now we will just remove and add every file so we get an extra entry
303
# per entry. Unversion in reverse order so we handle subdirs
304
tree.unversion(['f-id', 'b-c-id', 'e-id', 'd-id', 'c-id', 'b-id', 'a-id'])
305
tree.add(['a', 'b', 'b/c', 'b/d', 'b/d/e', 'b-c', 'f'],
306
['a-id2', 'b-id2', 'c-id2', 'd-id2', 'e-id2', 'b-c-id2', 'f-id2'])
308
# Update the expected dictionary.
309
for path in ['a', 'b', 'b/c', 'b/d', 'b/d/e', 'b-c', 'f']:
310
orig = expected[path]
312
# This record was deleted in the current tree
313
expected[path] = (orig[0], [dirstate.DirState.NULL_PARENT_DETAILS,
315
new_key = (orig[0][0], orig[0][1], orig[0][2]+'2')
316
# And didn't exist in the basis tree
317
expected[path2] = (new_key, [orig[1][0],
318
dirstate.DirState.NULL_PARENT_DETAILS])
320
# We will replace the 'dirstate' file underneath 'state', but that is
321
# okay as lock as we unlock 'state' first.
324
new_state = dirstate.DirState.from_tree(tree, 'dirstate')
330
# But we need to leave state in a read-lock because we already have
331
# a cleanup scheduled
333
return tree, state, expected
335
def create_renamed_dirstate(self):
336
"""Create a dirstate with a few internal renames.
338
This takes the basic dirstate, and moves the paths around.
340
tree, state, expected = self.create_basic_dirstate()
342
tree.rename_one('a', 'b/g')
344
tree.rename_one('b/d', 'h')
346
old_a = expected['a']
347
expected['a'] = (old_a[0], [('r', 'b/g', 0, False, ''), old_a[1][1]])
348
expected['b/g'] = (('b', 'g', 'a-id'), [old_a[1][0],
349
('r', 'a', 0, False, '')])
350
old_d = expected['b/d']
351
expected['b/d'] = (old_d[0], [('r', 'h', 0, False, ''), old_d[1][1]])
352
expected['h'] = (('', 'h', 'd-id'), [old_d[1][0],
353
('r', 'b/d', 0, False, '')])
355
old_e = expected['b/d/e']
356
expected['b/d/e'] = (old_e[0], [('r', 'h/e', 0, False, ''),
358
expected['h/e'] = (('h', 'e', 'e-id'), [old_e[1][0],
359
('r', 'b/d/e', 0, False, '')])
363
new_state = dirstate.DirState.from_tree(tree, 'dirstate')
370
return tree, state, expected
373
class TestTreeToDirState(TestCaseWithDirState):
375
def test_empty_to_dirstate(self):
376
"""We should be able to create a dirstate for an empty tree."""
377
# There are no files on disk and no parents
378
tree = self.make_branch_and_tree('tree')
379
expected_result = ([], [
380
(('', '', tree.get_root_id()), # common details
381
[('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
383
state = dirstate.DirState.from_tree(tree, 'dirstate')
385
self.check_state_with_reopen(expected_result, state)
387
def test_1_parents_empty_to_dirstate(self):
388
# create a parent by doing a commit
389
tree = self.make_branch_and_tree('tree')
390
rev_id = tree.commit('first post').encode('utf8')
391
root_stat_pack = dirstate.pack_stat(os.stat(tree.basedir))
392
expected_result = ([rev_id], [
393
(('', '', tree.get_root_id()), # common details
394
[('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
395
('d', '', 0, False, rev_id), # first parent details
397
state = dirstate.DirState.from_tree(tree, 'dirstate')
398
self.check_state_with_reopen(expected_result, state)
405
def test_2_parents_empty_to_dirstate(self):
406
# create a parent by doing a commit
407
tree = self.make_branch_and_tree('tree')
408
rev_id = tree.commit('first post')
409
tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
410
rev_id2 = tree2.commit('second post', allow_pointless=True)
411
tree.merge_from_branch(tree2.branch)
412
expected_result = ([rev_id, rev_id2], [
413
(('', '', tree.get_root_id()), # common details
414
[('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
415
('d', '', 0, False, rev_id), # first parent details
416
('d', '', 0, False, rev_id), # second parent details
418
state = dirstate.DirState.from_tree(tree, 'dirstate')
419
self.check_state_with_reopen(expected_result, state)
426
def test_empty_unknowns_are_ignored_to_dirstate(self):
427
"""We should be able to create a dirstate for an empty tree."""
428
# There are no files on disk and no parents
429
tree = self.make_branch_and_tree('tree')
430
self.build_tree(['tree/unknown'])
431
expected_result = ([], [
432
(('', '', tree.get_root_id()), # common details
433
[('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
435
state = dirstate.DirState.from_tree(tree, 'dirstate')
436
self.check_state_with_reopen(expected_result, state)
438
def get_tree_with_a_file(self):
439
tree = self.make_branch_and_tree('tree')
440
self.build_tree(['tree/a file'])
441
tree.add('a file', 'a-file-id')
444
def test_non_empty_no_parents_to_dirstate(self):
445
"""We should be able to create a dirstate for an empty tree."""
446
# There are files on disk and no parents
447
tree = self.get_tree_with_a_file()
448
expected_result = ([], [
449
(('', '', tree.get_root_id()), # common details
450
[('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
452
(('', 'a file', 'a-file-id'), # common
453
[('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
456
state = dirstate.DirState.from_tree(tree, 'dirstate')
457
self.check_state_with_reopen(expected_result, state)
459
def test_1_parents_not_empty_to_dirstate(self):
460
# create a parent by doing a commit
461
tree = self.get_tree_with_a_file()
462
rev_id = tree.commit('first post').encode('utf8')
463
# change the current content to be different this will alter stat, sha
465
self.build_tree_contents([('tree/a file', 'new content\n')])
466
expected_result = ([rev_id], [
467
(('', '', tree.get_root_id()), # common details
468
[('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
469
('d', '', 0, False, rev_id), # first parent details
471
(('', 'a file', 'a-file-id'), # common
472
[('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
473
('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
474
rev_id), # first parent
477
state = dirstate.DirState.from_tree(tree, 'dirstate')
478
self.check_state_with_reopen(expected_result, state)
480
def test_2_parents_not_empty_to_dirstate(self):
481
# create a parent by doing a commit
482
tree = self.get_tree_with_a_file()
483
rev_id = tree.commit('first post').encode('utf8')
484
tree2 = tree.bzrdir.sprout('tree2').open_workingtree()
485
# change the current content to be different this will alter stat, sha
487
self.build_tree_contents([('tree2/a file', 'merge content\n')])
488
rev_id2 = tree2.commit('second post').encode('utf8')
489
tree.merge_from_branch(tree2.branch)
490
# change the current content to be different this will alter stat, sha
491
# and length again, giving us three distinct values:
492
self.build_tree_contents([('tree/a file', 'new content\n')])
493
expected_result = ([rev_id, rev_id2], [
494
(('', '', tree.get_root_id()), # common details
495
[('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
496
('d', '', 0, False, rev_id), # first parent details
497
('d', '', 0, False, rev_id), # second parent details
499
(('', 'a file', 'a-file-id'), # common
500
[('f', '', 0, False, dirstate.DirState.NULLSTAT), # current
501
('f', 'c3ed76e4bfd45ff1763ca206055bca8e9fc28aa8', 24, False,
502
rev_id), # first parent
503
('f', '314d796174c9412647c3ce07dfb5d36a94e72958', 14, False,
504
rev_id2), # second parent
507
state = dirstate.DirState.from_tree(tree, 'dirstate')
508
self.check_state_with_reopen(expected_result, state)
510
def test_colliding_fileids(self):
511
# test insertion of parents creating several entries at the same path.
512
# we used to have a bug where they could cause the dirstate to break
513
# its ordering invariants.
514
# create some trees to test from
517
tree = self.make_branch_and_tree('tree%d' % i)
518
self.build_tree(['tree%d/name' % i,])
519
tree.add(['name'], ['file-id%d' % i])
520
revision_id = 'revid-%d' % i
521
tree.commit('message', rev_id=revision_id)
522
parents.append((revision_id,
523
tree.branch.repository.revision_tree(revision_id)))
524
# now fold these trees into a dirstate
525
state = dirstate.DirState.initialize('dirstate')
527
state.set_parent_trees(parents, [])
533
class TestDirStateOnFile(TestCaseWithDirState):
535
def create_updated_dirstate(self):
536
self.build_tree(['a-file'])
537
tree = self.make_branch_and_tree('.')
538
tree.add(['a-file'], ['a-id'])
539
tree.commit('add a-file')
540
# Save and unlock the state, re-open it in readonly mode
541
state = dirstate.DirState.from_tree(tree, 'dirstate')
544
state = dirstate.DirState.on_file('dirstate')
548
def test_construct_with_path(self):
549
tree = self.make_branch_and_tree('tree')
550
state = dirstate.DirState.from_tree(tree, 'dirstate.from_tree')
551
# we want to be able to get the lines of the dirstate that we will
553
lines = state.get_lines()
555
self.build_tree_contents([('dirstate', ''.join(lines))])
557
# no parents, default tree content
558
expected_result = ([], [
559
(('', '', tree.get_root_id()), # common details
560
# current tree details, but new from_tree skips statting, it
561
# uses set_state_from_inventory, and thus depends on the
563
[('d', '', 0, False, dirstate.DirState.NULLSTAT),
566
state = dirstate.DirState.on_file('dirstate')
567
state.lock_write() # check_state_with_reopen will save() and unlock it
568
self.check_state_with_reopen(expected_result, state)
570
def test_can_save_clean_on_file(self):
571
tree = self.make_branch_and_tree('tree')
572
state = dirstate.DirState.from_tree(tree, 'dirstate')
574
# doing a save should work here as there have been no changes.
576
# TODO: stat it and check it hasn't changed; may require waiting
577
# for the state accuracy window.
581
def test_can_save_in_read_lock(self):
582
state = self.create_updated_dirstate()
584
entry = state._get_entry(0, path_utf8='a-file')
585
# The current size should be 0 (default)
586
self.assertEqual(0, entry[1][0][2])
587
# We should have a real entry.
588
self.assertNotEqual((None, None), entry)
589
# Set the cutoff-time into the future, so things look cacheable
590
state._sha_cutoff_time()
591
state._cutoff_time += 10.0
592
st = os.lstat('a-file')
593
sha1sum = dirstate.update_entry(state, entry, 'a-file', st)
594
# We updated the current sha1sum because the file is cacheable
595
self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
598
# The dirblock has been updated
599
self.assertEqual(st.st_size, entry[1][0][2])
600
self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
601
state._dirblock_state)
604
# Now, since we are the only one holding a lock, we should be able
605
# to save and have it written to disk
610
# Re-open the file, and ensure that the state has been updated.
611
state = dirstate.DirState.on_file('dirstate')
614
entry = state._get_entry(0, path_utf8='a-file')
615
self.assertEqual(st.st_size, entry[1][0][2])
619
def test_save_fails_quietly_if_locked(self):
620
"""If dirstate is locked, save will fail without complaining."""
621
state = self.create_updated_dirstate()
623
entry = state._get_entry(0, path_utf8='a-file')
624
# No cached sha1 yet.
625
self.assertEqual('', entry[1][0][1])
626
# Set the cutoff-time into the future, so things look cacheable
627
state._sha_cutoff_time()
628
state._cutoff_time += 10.0
629
st = os.lstat('a-file')
630
sha1sum = dirstate.update_entry(state, entry, 'a-file', st)
631
self.assertEqual('ecc5374e9ed82ad3ea3b4d452ea995a5fd3e70e3',
633
self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
634
state._dirblock_state)
636
# Now, before we try to save, grab another dirstate, and take out a
638
# TODO: jam 20070315 Ideally this would be locked by another
639
# process. To make sure the file is really OS locked.
640
state2 = dirstate.DirState.on_file('dirstate')
643
# This won't actually write anything, because it couldn't grab
644
# a write lock. But it shouldn't raise an error, either.
645
# TODO: jam 20070315 We should probably distinguish between
646
# being dirty because of 'update_entry'. And dirty
647
# because of real modification. So that save() *does*
648
# raise a real error if it fails when we have real
656
# The file on disk should not be modified.
657
state = dirstate.DirState.on_file('dirstate')
660
entry = state._get_entry(0, path_utf8='a-file')
661
self.assertEqual('', entry[1][0][1])
665
def test_save_refuses_if_changes_aborted(self):
666
self.build_tree(['a-file', 'a-dir/'])
667
state = dirstate.DirState.initialize('dirstate')
669
# No stat and no sha1 sum.
670
state.add('a-file', 'a-file-id', 'file', None, '')
675
# The dirstate should include TREE_ROOT and 'a-file' and nothing else
677
('', [(('', '', 'TREE_ROOT'),
678
[('d', '', 0, False, dirstate.DirState.NULLSTAT)])]),
679
('', [(('', 'a-file', 'a-file-id'),
680
[('f', '', 0, False, dirstate.DirState.NULLSTAT)])]),
683
state = dirstate.DirState.on_file('dirstate')
686
state._read_dirblocks_if_needed()
687
self.assertEqual(expected_blocks, state._dirblocks)
689
# Now modify the state, but mark it as inconsistent
690
state.add('a-dir', 'a-dir-id', 'directory', None, '')
691
state._changes_aborted = True
696
state = dirstate.DirState.on_file('dirstate')
699
state._read_dirblocks_if_needed()
700
self.assertEqual(expected_blocks, state._dirblocks)
705
class TestDirStateInitialize(TestCaseWithDirState):
707
def test_initialize(self):
708
expected_result = ([], [
709
(('', '', 'TREE_ROOT'), # common details
710
[('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
713
state = dirstate.DirState.initialize('dirstate')
715
self.assertIsInstance(state, dirstate.DirState)
716
lines = state.get_lines()
719
# On win32 you can't read from a locked file, even within the same
720
# process. So we have to unlock and release before we check the file
722
self.assertFileEqual(''.join(lines), 'dirstate')
723
state.lock_read() # check_state_with_reopen will unlock
724
self.check_state_with_reopen(expected_result, state)
727
class TestDirStateManipulations(TestCaseWithDirState):
729
def make_minimal_tree(self):
730
tree1 = self.make_branch_and_memory_tree('tree1')
732
self.addCleanup(tree1.unlock)
734
revid1 = tree1.commit('foo')
737
def test_update_minimal_updates_id_index(self):
738
state = self.create_dirstate_with_root_and_subdir()
739
self.addCleanup(state.unlock)
740
id_index = state._get_id_index()
741
self.assertEqual(['a-root-value', 'subdir-id'], sorted(id_index))
742
state.add('file-name', 'file-id', 'file', None, '')
743
self.assertEqual(['a-root-value', 'file-id', 'subdir-id'],
745
state.update_minimal(('', 'new-name', 'file-id'), 'f',
746
path_utf8='new-name')
747
self.assertEqual(['a-root-value', 'file-id', 'subdir-id'],
749
self.assertEqual([('', 'new-name', 'file-id')],
750
sorted(id_index['file-id']))
753
def test_set_state_from_inventory_no_content_no_parents(self):
754
# setting the current inventory is a slow but important api to support.
755
tree1, revid1 = self.make_minimal_tree()
756
inv = tree1.inventory
757
root_id = inv.path2id('')
758
expected_result = [], [
759
(('', '', root_id), [
760
('d', '', 0, False, dirstate.DirState.NULLSTAT)])]
761
state = dirstate.DirState.initialize('dirstate')
763
state.set_state_from_inventory(inv)
764
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
766
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
767
state._dirblock_state)
772
# This will unlock it
773
self.check_state_with_reopen(expected_result, state)
775
def test_set_state_from_scratch_no_parents(self):
776
tree1, revid1 = self.make_minimal_tree()
777
inv = tree1.inventory
778
root_id = inv.path2id('')
779
expected_result = [], [
780
(('', '', root_id), [
781
('d', '', 0, False, dirstate.DirState.NULLSTAT)])]
782
state = dirstate.DirState.initialize('dirstate')
784
state.set_state_from_scratch(inv, [], [])
785
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
787
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
788
state._dirblock_state)
793
# This will unlock it
794
self.check_state_with_reopen(expected_result, state)
796
def test_set_state_from_scratch_identical_parent(self):
797
tree1, revid1 = self.make_minimal_tree()
798
inv = tree1.inventory
799
root_id = inv.path2id('')
800
rev_tree1 = tree1.branch.repository.revision_tree(revid1)
801
d_entry = ('d', '', 0, False, dirstate.DirState.NULLSTAT)
802
parent_entry = ('d', '', 0, False, revid1)
803
expected_result = [revid1], [
804
(('', '', root_id), [d_entry, parent_entry])]
805
state = dirstate.DirState.initialize('dirstate')
807
state.set_state_from_scratch(inv, [(revid1, rev_tree1)], [])
808
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
810
self.assertEqual(dirstate.DirState.IN_MEMORY_MODIFIED,
811
state._dirblock_state)
816
# This will unlock it
817
self.check_state_with_reopen(expected_result, state)
819
def test_set_state_from_inventory_preserves_hashcache(self):
820
# https://bugs.launchpad.net/bzr/+bug/146176
821
# set_state_from_inventory should preserve the stat and hash value for
822
# workingtree files that are not changed by the inventory.
824
tree = self.make_branch_and_tree('.')
825
# depends on the default format using dirstate...
828
# make a dirstate with some valid hashcache data
829
# file on disk, but that's not needed for this test
830
foo_contents = 'contents of foo'
831
self.build_tree_contents([('foo', foo_contents)])
832
tree.add('foo', 'foo-id')
834
foo_stat = os.stat('foo')
835
foo_packed = dirstate.pack_stat(foo_stat)
836
foo_sha = osutils.sha_string(foo_contents)
837
foo_size = len(foo_contents)
839
# should not be cached yet, because the file's too fresh
841
(('', 'foo', 'foo-id',),
842
[('f', '', 0, False, dirstate.DirState.NULLSTAT)]),
843
tree._dirstate._get_entry(0, 'foo-id'))
844
# poke in some hashcache information - it wouldn't normally be
845
# stored because it's too fresh
846
tree._dirstate.update_minimal(
847
('', 'foo', 'foo-id'),
848
'f', False, foo_sha, foo_packed, foo_size, 'foo')
849
# now should be cached
851
(('', 'foo', 'foo-id',),
852
[('f', foo_sha, foo_size, False, foo_packed)]),
853
tree._dirstate._get_entry(0, 'foo-id'))
855
# extract the inventory, and add something to it
856
inv = tree._get_inventory()
857
# should see the file we poked in...
858
self.assertTrue(inv.has_id('foo-id'))
859
self.assertTrue(inv.has_filename('foo'))
860
inv.add_path('bar', 'file', 'bar-id')
861
tree._dirstate._validate()
862
# this used to cause it to lose its hashcache
863
tree._dirstate.set_state_from_inventory(inv)
864
tree._dirstate._validate()
870
# now check that the state still has the original hashcache value
871
state = tree._dirstate
873
foo_tuple = state._get_entry(0, path_utf8='foo')
875
(('', 'foo', 'foo-id',),
876
[('f', foo_sha, len(foo_contents), False,
877
dirstate.pack_stat(foo_stat))]),
882
def test_set_state_from_inventory_mixed_paths(self):
883
tree1 = self.make_branch_and_tree('tree1')
884
self.build_tree(['tree1/a/', 'tree1/a/b/', 'tree1/a-b/',
885
'tree1/a/b/foo', 'tree1/a-b/bar'])
888
tree1.add(['a', 'a/b', 'a-b', 'a/b/foo', 'a-b/bar'],
889
['a-id', 'b-id', 'a-b-id', 'foo-id', 'bar-id'])
890
tree1.commit('rev1', rev_id='rev1')
891
root_id = tree1.get_root_id()
892
inv = tree1.inventory
895
expected_result1 = [('', '', root_id, 'd'),
896
('', 'a', 'a-id', 'd'),
897
('', 'a-b', 'a-b-id', 'd'),
898
('a', 'b', 'b-id', 'd'),
899
('a/b', 'foo', 'foo-id', 'f'),
900
('a-b', 'bar', 'bar-id', 'f'),
902
expected_result2 = [('', '', root_id, 'd'),
903
('', 'a', 'a-id', 'd'),
904
('', 'a-b', 'a-b-id', 'd'),
905
('a-b', 'bar', 'bar-id', 'f'),
907
state = dirstate.DirState.initialize('dirstate')
909
state.set_state_from_inventory(inv)
911
for entry in state._iter_entries():
912
values.append(entry[0] + entry[1][0][:1])
913
self.assertEqual(expected_result1, values)
915
state.set_state_from_inventory(inv)
917
for entry in state._iter_entries():
918
values.append(entry[0] + entry[1][0][:1])
919
self.assertEqual(expected_result2, values)
923
def test_set_path_id_no_parents(self):
924
"""The id of a path can be changed trivally with no parents."""
925
state = dirstate.DirState.initialize('dirstate')
927
# check precondition to be sure the state does change appropriately.
928
root_entry = (('', '', 'TREE_ROOT'), [('d', '', 0, False, 'x'*32)])
929
self.assertEqual([root_entry], list(state._iter_entries()))
930
self.assertEqual(root_entry, state._get_entry(0, path_utf8=''))
931
self.assertEqual(root_entry,
932
state._get_entry(0, fileid_utf8='TREE_ROOT'))
933
self.assertEqual((None, None),
934
state._get_entry(0, fileid_utf8='second-root-id'))
935
state.set_path_id('', 'second-root-id')
936
new_root_entry = (('', '', 'second-root-id'),
937
[('d', '', 0, False, 'x'*32)])
938
expected_rows = [new_root_entry]
939
self.assertEqual(expected_rows, list(state._iter_entries()))
940
self.assertEqual(new_root_entry, state._get_entry(0, path_utf8=''))
941
self.assertEqual(new_root_entry,
942
state._get_entry(0, fileid_utf8='second-root-id'))
943
self.assertEqual((None, None),
944
state._get_entry(0, fileid_utf8='TREE_ROOT'))
945
# should work across save too
949
state = dirstate.DirState.on_file('dirstate')
953
self.assertEqual(expected_rows, list(state._iter_entries()))
957
def test_set_path_id_with_parents(self):
958
"""Set the root file id in a dirstate with parents"""
959
mt = self.make_branch_and_tree('mt')
960
# in case the default tree format uses a different root id
961
mt.set_root_id('TREE_ROOT')
962
mt.commit('foo', rev_id='parent-revid')
963
rt = mt.branch.repository.revision_tree('parent-revid')
964
state = dirstate.DirState.initialize('dirstate')
967
state.set_parent_trees([('parent-revid', rt)], ghosts=[])
968
root_entry = (('', '', 'TREE_ROOT'),
969
[('d', '', 0, False, 'x'*32),
970
('d', '', 0, False, 'parent-revid')])
971
self.assertEqual(root_entry, state._get_entry(0, path_utf8=''))
972
self.assertEqual(root_entry,
973
state._get_entry(0, fileid_utf8='TREE_ROOT'))
974
self.assertEqual((None, None),
975
state._get_entry(0, fileid_utf8='Asecond-root-id'))
976
state.set_path_id('', 'Asecond-root-id')
978
# now see that it is what we expected
979
old_root_entry = (('', '', 'TREE_ROOT'),
980
[('a', '', 0, False, ''),
981
('d', '', 0, False, 'parent-revid')])
982
new_root_entry = (('', '', 'Asecond-root-id'),
983
[('d', '', 0, False, ''),
984
('a', '', 0, False, '')])
985
expected_rows = [new_root_entry, old_root_entry]
987
self.assertEqual(expected_rows, list(state._iter_entries()))
988
self.assertEqual(new_root_entry, state._get_entry(0, path_utf8=''))
989
self.assertEqual(old_root_entry, state._get_entry(1, path_utf8=''))
990
self.assertEqual((None, None),
991
state._get_entry(0, fileid_utf8='TREE_ROOT'))
992
self.assertEqual(old_root_entry,
993
state._get_entry(1, fileid_utf8='TREE_ROOT'))
994
self.assertEqual(new_root_entry,
995
state._get_entry(0, fileid_utf8='Asecond-root-id'))
996
self.assertEqual((None, None),
997
state._get_entry(1, fileid_utf8='Asecond-root-id'))
998
# should work across save too
1002
# now flush & check we get the same
1003
state = dirstate.DirState.on_file('dirstate')
1007
self.assertEqual(expected_rows, list(state._iter_entries()))
1010
# now change within an existing file-backed state
1014
state.set_path_id('', 'tree-root-2')
1019
def test_set_parent_trees_no_content(self):
1020
# set_parent_trees is a slow but important api to support.
1021
tree1 = self.make_branch_and_memory_tree('tree1')
1025
revid1 = tree1.commit('foo')
1028
branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
1029
tree2 = memorytree.MemoryTree.create_on_branch(branch2)
1032
revid2 = tree2.commit('foo')
1033
root_id = tree2.get_root_id()
1036
state = dirstate.DirState.initialize('dirstate')
1038
state.set_path_id('', root_id)
1039
state.set_parent_trees(
1040
((revid1, tree1.branch.repository.revision_tree(revid1)),
1041
(revid2, tree2.branch.repository.revision_tree(revid2)),
1042
('ghost-rev', None)),
1044
# check we can reopen and use the dirstate after setting parent
1051
state = dirstate.DirState.on_file('dirstate')
1054
self.assertEqual([revid1, revid2, 'ghost-rev'],
1055
state.get_parent_ids())
1056
# iterating the entire state ensures that the state is parsable.
1057
list(state._iter_entries())
1058
# be sure that it sets not appends - change it
1059
state.set_parent_trees(
1060
((revid1, tree1.branch.repository.revision_tree(revid1)),
1061
('ghost-rev', None)),
1063
# and now put it back.
1064
state.set_parent_trees(
1065
((revid1, tree1.branch.repository.revision_tree(revid1)),
1066
(revid2, tree2.branch.repository.revision_tree(revid2)),
1067
('ghost-rev', tree2.branch.repository.revision_tree(
1068
_mod_revision.NULL_REVISION))),
1070
self.assertEqual([revid1, revid2, 'ghost-rev'],
1071
state.get_parent_ids())
1072
# the ghost should be recorded as such by set_parent_trees.
1073
self.assertEqual(['ghost-rev'], state.get_ghosts())
1075
[(('', '', root_id), [
1076
('d', '', 0, False, dirstate.DirState.NULLSTAT),
1077
('d', '', 0, False, revid1),
1078
('d', '', 0, False, revid1)
1080
list(state._iter_entries()))
1084
def test_set_parent_trees_file_missing_from_tree(self):
1085
# Adding a parent tree may reference files not in the current state.
1086
# they should get listed just once by id, even if they are in two
1088
# set_parent_trees is a slow but important api to support.
1089
tree1 = self.make_branch_and_memory_tree('tree1')
1093
tree1.add(['a file'], ['file-id'], ['file'])
1094
tree1.put_file_bytes_non_atomic('file-id', 'file-content')
1095
revid1 = tree1.commit('foo')
1098
branch2 = tree1.branch.bzrdir.clone('tree2').open_branch()
1099
tree2 = memorytree.MemoryTree.create_on_branch(branch2)
1102
tree2.put_file_bytes_non_atomic('file-id', 'new file-content')
1103
revid2 = tree2.commit('foo')
1104
root_id = tree2.get_root_id()
1107
# check the layout in memory
1108
expected_result = [revid1.encode('utf8'), revid2.encode('utf8')], [
1109
(('', '', root_id), [
1110
('d', '', 0, False, dirstate.DirState.NULLSTAT),
1111
('d', '', 0, False, revid1.encode('utf8')),
1112
('d', '', 0, False, revid1.encode('utf8'))
1114
(('', 'a file', 'file-id'), [
1115
('a', '', 0, False, ''),
1116
('f', '2439573625385400f2a669657a7db6ae7515d371', 12, False,
1117
revid1.encode('utf8')),
1118
('f', '542e57dc1cda4af37cb8e55ec07ce60364bb3c7d', 16, False,
1119
revid2.encode('utf8'))
1122
state = dirstate.DirState.initialize('dirstate')
1124
state.set_path_id('', root_id)
1125
state.set_parent_trees(
1126
((revid1, tree1.branch.repository.revision_tree(revid1)),
1127
(revid2, tree2.branch.repository.revision_tree(revid2)),
1133
# check_state_with_reopen will unlock
1134
self.check_state_with_reopen(expected_result, state)
1136
### add a path via _set_data - so we dont need delta work, just
1137
# raw data in, and ensure that it comes out via get_lines happily.
1139
def test_add_path_to_root_no_parents_all_data(self):
1140
# The most trivial addition of a path is when there are no parents and
1141
# its in the root and all data about the file is supplied
1142
self.build_tree(['a file'])
1143
stat = os.lstat('a file')
1144
# the 1*20 is the sha1 pretend value.
1145
state = dirstate.DirState.initialize('dirstate')
1146
expected_entries = [
1147
(('', '', 'TREE_ROOT'), [
1148
('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1150
(('', 'a file', 'a-file-id'), [
1151
('f', '1'*20, 19, False, dirstate.pack_stat(stat)), # current tree
1155
state.add('a file', 'a-file-id', 'file', stat, '1'*20)
1156
# having added it, it should be in the output of iter_entries.
1157
self.assertEqual(expected_entries, list(state._iter_entries()))
1158
# saving and reloading should not affect this.
1162
state = dirstate.DirState.on_file('dirstate')
1164
self.addCleanup(state.unlock)
1165
self.assertEqual(expected_entries, list(state._iter_entries()))
1167
def test_add_path_to_unversioned_directory(self):
1168
"""Adding a path to an unversioned directory should error.
1170
This is a duplicate of TestWorkingTree.test_add_in_unversioned,
1171
once dirstate is stable and if it is merged with WorkingTree3, consider
1172
removing this copy of the test.
1174
self.build_tree(['unversioned/', 'unversioned/a file'])
1175
state = dirstate.DirState.initialize('dirstate')
1176
self.addCleanup(state.unlock)
1177
self.assertRaises(errors.NotVersionedError, state.add,
1178
'unversioned/a file', 'a-file-id', 'file', None, None)
1180
def test_add_directory_to_root_no_parents_all_data(self):
1181
# The most trivial addition of a dir is when there are no parents and
1182
# its in the root and all data about the file is supplied
1183
self.build_tree(['a dir/'])
1184
stat = os.lstat('a dir')
1185
expected_entries = [
1186
(('', '', 'TREE_ROOT'), [
1187
('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1189
(('', 'a dir', 'a dir id'), [
1190
('d', '', 0, False, dirstate.pack_stat(stat)), # current tree
1193
state = dirstate.DirState.initialize('dirstate')
1195
state.add('a dir', 'a dir id', 'directory', stat, None)
1196
# having added it, it should be in the output of iter_entries.
1197
self.assertEqual(expected_entries, list(state._iter_entries()))
1198
# saving and reloading should not affect this.
1202
state = dirstate.DirState.on_file('dirstate')
1204
self.addCleanup(state.unlock)
1206
self.assertEqual(expected_entries, list(state._iter_entries()))
1208
def _test_add_symlink_to_root_no_parents_all_data(self, link_name, target):
1209
# The most trivial addition of a symlink when there are no parents and
1210
# its in the root and all data about the file is supplied
1211
# bzr doesn't support fake symlinks on windows, yet.
1212
self.requireFeature(tests.SymlinkFeature)
1213
os.symlink(target, link_name)
1214
stat = os.lstat(link_name)
1215
expected_entries = [
1216
(('', '', 'TREE_ROOT'), [
1217
('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1219
(('', link_name.encode('UTF-8'), 'a link id'), [
1220
('l', target.encode('UTF-8'), stat[6],
1221
False, dirstate.pack_stat(stat)), # current tree
1224
state = dirstate.DirState.initialize('dirstate')
1226
state.add(link_name, 'a link id', 'symlink', stat,
1227
target.encode('UTF-8'))
1228
# having added it, it should be in the output of iter_entries.
1229
self.assertEqual(expected_entries, list(state._iter_entries()))
1230
# saving and reloading should not affect this.
1234
state = dirstate.DirState.on_file('dirstate')
1236
self.addCleanup(state.unlock)
1237
self.assertEqual(expected_entries, list(state._iter_entries()))
1239
def test_add_symlink_to_root_no_parents_all_data(self):
1240
self._test_add_symlink_to_root_no_parents_all_data('a link', 'target')
1242
def test_add_symlink_unicode_to_root_no_parents_all_data(self):
1243
self.requireFeature(tests.UnicodeFilenameFeature)
1244
self._test_add_symlink_to_root_no_parents_all_data(
1245
u'\N{Euro Sign}link', u'targ\N{Euro Sign}et')
1247
def test_add_directory_and_child_no_parents_all_data(self):
1248
# after adding a directory, we should be able to add children to it.
1249
self.build_tree(['a dir/', 'a dir/a file'])
1250
dirstat = os.lstat('a dir')
1251
filestat = os.lstat('a dir/a file')
1252
expected_entries = [
1253
(('', '', 'TREE_ROOT'), [
1254
('d', '', 0, False, dirstate.DirState.NULLSTAT), # current tree
1256
(('', 'a dir', 'a dir id'), [
1257
('d', '', 0, False, dirstate.pack_stat(dirstat)), # current tree
1259
(('a dir', 'a file', 'a-file-id'), [
1260
('f', '1'*20, 25, False,
1261
dirstate.pack_stat(filestat)), # current tree details
1264
state = dirstate.DirState.initialize('dirstate')
1266
state.add('a dir', 'a dir id', 'directory', dirstat, None)
1267
state.add('a dir/a file', 'a-file-id', 'file', filestat, '1'*20)
1268
# added it, it should be in the output of iter_entries.
1269
self.assertEqual(expected_entries, list(state._iter_entries()))
1270
# saving and reloading should not affect this.
1274
state = dirstate.DirState.on_file('dirstate')
1276
self.addCleanup(state.unlock)
1277
self.assertEqual(expected_entries, list(state._iter_entries()))
1279
def test_add_tree_reference(self):
1280
# make a dirstate and add a tree reference
1281
state = dirstate.DirState.initialize('dirstate')
1283
('', 'subdir', 'subdir-id'),
1284
[('t', 'subtree-123123', 0, False,
1285
'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')],
1288
state.add('subdir', 'subdir-id', 'tree-reference', None, 'subtree-123123')
1289
entry = state._get_entry(0, 'subdir-id', 'subdir')
1290
self.assertEqual(entry, expected_entry)
1295
# now check we can read it back
1297
self.addCleanup(state.unlock)
1299
entry2 = state._get_entry(0, 'subdir-id', 'subdir')
1300
self.assertEqual(entry, entry2)
1301
self.assertEqual(entry, expected_entry)
1302
# and lookup by id should work too
1303
entry2 = state._get_entry(0, fileid_utf8='subdir-id')
1304
self.assertEqual(entry, expected_entry)
1306
def test_add_forbidden_names(self):
1307
state = dirstate.DirState.initialize('dirstate')
1308
self.addCleanup(state.unlock)
1309
self.assertRaises(errors.BzrError,
1310
state.add, '.', 'ass-id', 'directory', None, None)
1311
self.assertRaises(errors.BzrError,
1312
state.add, '..', 'ass-id', 'directory', None, None)
1314
def test_set_state_with_rename_b_a_bug_395556(self):
1315
# bug 395556 uncovered a bug where the dirstate ends up with a false
1316
# relocation record - in a tree with no parents there should be no
1317
# absent or relocated records. This then leads to further corruption
1318
# when a commit occurs, as the incorrect relocation gathers an
1319
# incorrect absent in tree 1, and future changes go to pot.
1320
tree1 = self.make_branch_and_tree('tree1')
1321
self.build_tree(['tree1/b'])
1324
tree1.add(['b'], ['b-id'])
1325
root_id = tree1.get_root_id()
1326
inv = tree1.inventory
1327
state = dirstate.DirState.initialize('dirstate')
1329
# Set the initial state with 'b'
1330
state.set_state_from_inventory(inv)
1331
inv.rename('b-id', root_id, 'a')
1332
# Set the new state with 'a', which currently corrupts.
1333
state.set_state_from_inventory(inv)
1334
expected_result1 = [('', '', root_id, 'd'),
1335
('', 'a', 'b-id', 'f'),
1338
for entry in state._iter_entries():
1339
values.append(entry[0] + entry[1][0][:1])
1340
self.assertEqual(expected_result1, values)
1347
class TestDirStateHashUpdates(TestCaseWithDirState):
1349
def do_update_entry(self, state, path):
1350
entry = state._get_entry(0, path_utf8=path)
1351
stat = os.lstat(path)
1352
return dirstate.update_entry(state, entry, os.path.abspath(path), stat)
1354
def _read_state_content(self, state):
1355
"""Read the content of the dirstate file.
1357
On Windows when one process locks a file, you can't even open() the
1358
file in another process (to read it). So we go directly to
1359
state._state_file. This should always be the exact disk representation,
1360
so it is reasonable to do so.
1361
DirState also always seeks before reading, so it doesn't matter if we
1362
bump the file pointer.
1364
state._state_file.seek(0)
1365
return state._state_file.read()
1367
def test_worth_saving_limit_avoids_writing(self):
1368
tree = self.make_branch_and_tree('.')
1369
self.build_tree(['c', 'd'])
1371
tree.add(['c', 'd'], ['c-id', 'd-id'])
1372
tree.commit('add c and d')
1373
state = InstrumentedDirState.on_file(tree.current_dirstate()._filename,
1374
worth_saving_limit=2)
1377
self.addCleanup(state.unlock)
1378
state._read_dirblocks_if_needed()
1379
state.adjust_time(+20) # Allow things to be cached
1380
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1381
state._dirblock_state)
1382
content = self._read_state_content(state)
1383
self.do_update_entry(state, 'c')
1384
self.assertEqual(1, len(state._known_hash_changes))
1385
self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
1386
state._dirblock_state)
1388
# It should not have set the state to IN_MEMORY_UNMODIFIED because the
1389
# hash values haven't been written out.
1390
self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
1391
state._dirblock_state)
1392
self.assertEqual(content, self._read_state_content(state))
1393
self.assertEqual(dirstate.DirState.IN_MEMORY_HASH_MODIFIED,
1394
state._dirblock_state)
1395
self.do_update_entry(state, 'd')
1396
self.assertEqual(2, len(state._known_hash_changes))
1398
self.assertEqual(dirstate.DirState.IN_MEMORY_UNMODIFIED,
1399
state._dirblock_state)
1400
self.assertEqual(0, len(state._known_hash_changes))
1403
class TestGetLines(TestCaseWithDirState):
1405
def test_get_line_with_2_rows(self):
1406
state = self.create_dirstate_with_root_and_subdir()
1408
self.assertEqual(['#bazaar dirstate flat format 3\n',
1409
'crc32: 41262208\n',
1413
'\x00\x00a-root-value\x00'
1414
'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00\n\x00'
1415
'\x00subdir\x00subdir-id\x00'
1416
'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00\n\x00'
1417
], state.get_lines())
1421
def test_entry_to_line(self):
1422
state = self.create_dirstate_with_root()
1425
'\x00\x00a-root-value\x00d\x00\x000\x00n'
1426
'\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk',
1427
state._entry_to_line(state._dirblocks[0][1][0]))
1431
def test_entry_to_line_with_parent(self):
1432
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
1433
root_entry = ('', '', 'a-root-value'), [
1434
('d', '', 0, False, packed_stat), # current tree details
1435
# first: a pointer to the current location
1436
('a', 'dirname/basename', 0, False, ''),
1438
state = dirstate.DirState.initialize('dirstate')
1441
'\x00\x00a-root-value\x00'
1442
'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00'
1443
'a\x00dirname/basename\x000\x00n\x00',
1444
state._entry_to_line(root_entry))
1448
def test_entry_to_line_with_two_parents_at_different_paths(self):
1449
# / in the tree, at / in one parent and /dirname/basename in the other.
1450
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
1451
root_entry = ('', '', 'a-root-value'), [
1452
('d', '', 0, False, packed_stat), # current tree details
1453
('d', '', 0, False, 'rev_id'), # first parent details
1454
# second: a pointer to the current location
1455
('a', 'dirname/basename', 0, False, ''),
1457
state = dirstate.DirState.initialize('dirstate')
1460
'\x00\x00a-root-value\x00'
1461
'd\x00\x000\x00n\x00AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk\x00'
1462
'd\x00\x000\x00n\x00rev_id\x00'
1463
'a\x00dirname/basename\x000\x00n\x00',
1464
state._entry_to_line(root_entry))
1468
def test_iter_entries(self):
1469
# we should be able to iterate the dirstate entries from end to end
1470
# this is for get_lines to be easy to read.
1471
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
1473
root_entries = [(('', '', 'a-root-value'), [
1474
('d', '', 0, False, packed_stat), # current tree details
1476
dirblocks.append(('', root_entries))
1477
# add two files in the root
1478
subdir_entry = ('', 'subdir', 'subdir-id'), [
1479
('d', '', 0, False, packed_stat), # current tree details
1481
afile_entry = ('', 'afile', 'afile-id'), [
1482
('f', 'sha1value', 34, False, packed_stat), # current tree details
1484
dirblocks.append(('', [subdir_entry, afile_entry]))
1486
file_entry2 = ('subdir', '2file', '2file-id'), [
1487
('f', 'sha1value', 23, False, packed_stat), # current tree details
1489
dirblocks.append(('subdir', [file_entry2]))
1490
state = dirstate.DirState.initialize('dirstate')
1492
state._set_data([], dirblocks)
1493
expected_entries = [root_entries[0], subdir_entry, afile_entry,
1495
self.assertEqual(expected_entries, list(state._iter_entries()))
1500
class TestGetBlockRowIndex(TestCaseWithDirState):
1502
def assertBlockRowIndexEqual(self, block_index, row_index, dir_present,
1503
file_present, state, dirname, basename, tree_index):
1504
self.assertEqual((block_index, row_index, dir_present, file_present),
1505
state._get_block_entry_index(dirname, basename, tree_index))
1507
block = state._dirblocks[block_index]
1508
self.assertEqual(dirname, block[0])
1509
if dir_present and file_present:
1510
row = state._dirblocks[block_index][1][row_index]
1511
self.assertEqual(dirname, row[0][0])
1512
self.assertEqual(basename, row[0][1])
1514
def test_simple_structure(self):
1515
state = self.create_dirstate_with_root_and_subdir()
1516
self.addCleanup(state.unlock)
1517
self.assertBlockRowIndexEqual(1, 0, True, True, state, '', 'subdir', 0)
1518
self.assertBlockRowIndexEqual(1, 0, True, False, state, '', 'bdir', 0)
1519
self.assertBlockRowIndexEqual(1, 1, True, False, state, '', 'zdir', 0)
1520
self.assertBlockRowIndexEqual(2, 0, False, False, state, 'a', 'foo', 0)
1521
self.assertBlockRowIndexEqual(2, 0, False, False, state,
1524
def test_complex_structure_exists(self):
1525
state = self.create_complex_dirstate()
1526
self.addCleanup(state.unlock)
1527
# Make sure we can find everything that exists
1528
self.assertBlockRowIndexEqual(0, 0, True, True, state, '', '', 0)
1529
self.assertBlockRowIndexEqual(1, 0, True, True, state, '', 'a', 0)
1530
self.assertBlockRowIndexEqual(1, 1, True, True, state, '', 'b', 0)
1531
self.assertBlockRowIndexEqual(1, 2, True, True, state, '', 'c', 0)
1532
self.assertBlockRowIndexEqual(1, 3, True, True, state, '', 'd', 0)
1533
self.assertBlockRowIndexEqual(2, 0, True, True, state, 'a', 'e', 0)
1534
self.assertBlockRowIndexEqual(2, 1, True, True, state, 'a', 'f', 0)
1535
self.assertBlockRowIndexEqual(3, 0, True, True, state, 'b', 'g', 0)
1536
self.assertBlockRowIndexEqual(3, 1, True, True, state,
1537
'b', 'h\xc3\xa5', 0)
1539
def test_complex_structure_missing(self):
1540
state = self.create_complex_dirstate()
1541
self.addCleanup(state.unlock)
1542
# Make sure things would be inserted in the right locations
1543
# '_' comes before 'a'
1544
self.assertBlockRowIndexEqual(0, 0, True, True, state, '', '', 0)
1545
self.assertBlockRowIndexEqual(1, 0, True, False, state, '', '_', 0)
1546
self.assertBlockRowIndexEqual(1, 1, True, False, state, '', 'aa', 0)
1547
self.assertBlockRowIndexEqual(1, 4, True, False, state,
1549
self.assertBlockRowIndexEqual(2, 0, False, False, state, '_', 'a', 0)
1550
self.assertBlockRowIndexEqual(3, 0, False, False, state, 'aa', 'a', 0)
1551
self.assertBlockRowIndexEqual(4, 0, False, False, state, 'bb', 'a', 0)
1552
# This would be inserted between a/ and b/
1553
self.assertBlockRowIndexEqual(3, 0, False, False, state, 'a/e', 'a', 0)
1555
self.assertBlockRowIndexEqual(4, 0, False, False, state, 'e', 'a', 0)
1558
class TestGetEntry(TestCaseWithDirState):
1560
def assertEntryEqual(self, dirname, basename, file_id, state, path, index):
1561
"""Check that the right entry is returned for a request to getEntry."""
1562
entry = state._get_entry(index, path_utf8=path)
1564
self.assertEqual((None, None), entry)
1567
self.assertEqual((dirname, basename, file_id), cur[:3])
1569
def test_simple_structure(self):
1570
state = self.create_dirstate_with_root_and_subdir()
1571
self.addCleanup(state.unlock)
1572
self.assertEntryEqual('', '', 'a-root-value', state, '', 0)
1573
self.assertEntryEqual('', 'subdir', 'subdir-id', state, 'subdir', 0)
1574
self.assertEntryEqual(None, None, None, state, 'missing', 0)
1575
self.assertEntryEqual(None, None, None, state, 'missing/foo', 0)
1576
self.assertEntryEqual(None, None, None, state, 'subdir/foo', 0)
1578
def test_complex_structure_exists(self):
1579
state = self.create_complex_dirstate()
1580
self.addCleanup(state.unlock)
1581
self.assertEntryEqual('', '', 'a-root-value', state, '', 0)
1582
self.assertEntryEqual('', 'a', 'a-dir', state, 'a', 0)
1583
self.assertEntryEqual('', 'b', 'b-dir', state, 'b', 0)
1584
self.assertEntryEqual('', 'c', 'c-file', state, 'c', 0)
1585
self.assertEntryEqual('', 'd', 'd-file', state, 'd', 0)
1586
self.assertEntryEqual('a', 'e', 'e-dir', state, 'a/e', 0)
1587
self.assertEntryEqual('a', 'f', 'f-file', state, 'a/f', 0)
1588
self.assertEntryEqual('b', 'g', 'g-file', state, 'b/g', 0)
1589
self.assertEntryEqual('b', 'h\xc3\xa5', 'h-\xc3\xa5-file', state,
1592
def test_complex_structure_missing(self):
1593
state = self.create_complex_dirstate()
1594
self.addCleanup(state.unlock)
1595
self.assertEntryEqual(None, None, None, state, '_', 0)
1596
self.assertEntryEqual(None, None, None, state, '_\xc3\xa5', 0)
1597
self.assertEntryEqual(None, None, None, state, 'a/b', 0)
1598
self.assertEntryEqual(None, None, None, state, 'c/d', 0)
1600
def test_get_entry_uninitialized(self):
1601
"""Calling get_entry will load data if it needs to"""
1602
state = self.create_dirstate_with_root()
1608
state = dirstate.DirState.on_file('dirstate')
1611
self.assertEqual(dirstate.DirState.NOT_IN_MEMORY,
1612
state._header_state)
1613
self.assertEqual(dirstate.DirState.NOT_IN_MEMORY,
1614
state._dirblock_state)
1615
self.assertEntryEqual('', '', 'a-root-value', state, '', 0)
1620
class TestIterChildEntries(TestCaseWithDirState):
1622
def create_dirstate_with_two_trees(self):
1623
"""This dirstate contains multiple files and directories.
1633
b/h\xc3\xa5 h-\xc3\xa5-file #This is u'\xe5' encoded into utf-8
1635
Notice that a/e is an empty directory.
1637
There is one parent tree, which has the same shape with the following variations:
1638
b/g in the parent is gone.
1639
b/h in the parent has a different id
1640
b/i is new in the parent
1641
c is renamed to b/j in the parent
1643
:return: The dirstate, still write-locked.
1645
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
1646
null_sha = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
1647
NULL_PARENT_DETAILS = dirstate.DirState.NULL_PARENT_DETAILS
1648
root_entry = ('', '', 'a-root-value'), [
1649
('d', '', 0, False, packed_stat),
1650
('d', '', 0, False, 'parent-revid'),
1652
a_entry = ('', 'a', 'a-dir'), [
1653
('d', '', 0, False, packed_stat),
1654
('d', '', 0, False, 'parent-revid'),
1656
b_entry = ('', 'b', 'b-dir'), [
1657
('d', '', 0, False, packed_stat),
1658
('d', '', 0, False, 'parent-revid'),
1660
c_entry = ('', 'c', 'c-file'), [
1661
('f', null_sha, 10, False, packed_stat),
1662
('r', 'b/j', 0, False, ''),
1664
d_entry = ('', 'd', 'd-file'), [
1665
('f', null_sha, 20, False, packed_stat),
1666
('f', 'd', 20, False, 'parent-revid'),
1668
e_entry = ('a', 'e', 'e-dir'), [
1669
('d', '', 0, False, packed_stat),
1670
('d', '', 0, False, 'parent-revid'),
1672
f_entry = ('a', 'f', 'f-file'), [
1673
('f', null_sha, 30, False, packed_stat),
1674
('f', 'f', 20, False, 'parent-revid'),
1676
g_entry = ('b', 'g', 'g-file'), [
1677
('f', null_sha, 30, False, packed_stat),
1678
NULL_PARENT_DETAILS,
1680
h_entry1 = ('b', 'h\xc3\xa5', 'h-\xc3\xa5-file1'), [
1681
('f', null_sha, 40, False, packed_stat),
1682
NULL_PARENT_DETAILS,
1684
h_entry2 = ('b', 'h\xc3\xa5', 'h-\xc3\xa5-file2'), [
1685
NULL_PARENT_DETAILS,
1686
('f', 'h', 20, False, 'parent-revid'),
1688
i_entry = ('b', 'i', 'i-file'), [
1689
NULL_PARENT_DETAILS,
1690
('f', 'h', 20, False, 'parent-revid'),
1692
j_entry = ('b', 'j', 'c-file'), [
1693
('r', 'c', 0, False, ''),
1694
('f', 'j', 20, False, 'parent-revid'),
1697
dirblocks.append(('', [root_entry]))
1698
dirblocks.append(('', [a_entry, b_entry, c_entry, d_entry]))
1699
dirblocks.append(('a', [e_entry, f_entry]))
1700
dirblocks.append(('b', [g_entry, h_entry1, h_entry2, i_entry, j_entry]))
1701
state = dirstate.DirState.initialize('dirstate')
1704
state._set_data(['parent'], dirblocks)
1708
return state, dirblocks
1710
def test_iter_children_b(self):
1711
state, dirblocks = self.create_dirstate_with_two_trees()
1712
self.addCleanup(state.unlock)
1713
expected_result = []
1714
expected_result.append(dirblocks[3][1][2]) # h2
1715
expected_result.append(dirblocks[3][1][3]) # i
1716
expected_result.append(dirblocks[3][1][4]) # j
1717
self.assertEqual(expected_result,
1718
list(state._iter_child_entries(1, 'b')))
1720
def test_iter_child_root(self):
1721
state, dirblocks = self.create_dirstate_with_two_trees()
1722
self.addCleanup(state.unlock)
1723
expected_result = []
1724
expected_result.append(dirblocks[1][1][0]) # a
1725
expected_result.append(dirblocks[1][1][1]) # b
1726
expected_result.append(dirblocks[1][1][3]) # d
1727
expected_result.append(dirblocks[2][1][0]) # e
1728
expected_result.append(dirblocks[2][1][1]) # f
1729
expected_result.append(dirblocks[3][1][2]) # h2
1730
expected_result.append(dirblocks[3][1][3]) # i
1731
expected_result.append(dirblocks[3][1][4]) # j
1732
self.assertEqual(expected_result,
1733
list(state._iter_child_entries(1, '')))
1736
class TestDirstateSortOrder(tests.TestCaseWithTransport):
1737
"""Test that DirState adds entries in the right order."""
1739
def test_add_sorting(self):
1740
"""Add entries in lexicographical order, we get path sorted order.
1742
This tests it to a depth of 4, to make sure we don't just get it right
1743
at a single depth. 'a/a' should come before 'a-a', even though it
1744
doesn't lexicographically.
1746
dirs = ['a', 'a/a', 'a/a/a', 'a/a/a/a',
1747
'a-a', 'a/a-a', 'a/a/a-a', 'a/a/a/a-a',
1750
state = dirstate.DirState.initialize('dirstate')
1751
self.addCleanup(state.unlock)
1753
fake_stat = os.stat('dirstate')
1755
d_id = d.replace('/', '_')+'-id'
1756
file_path = d + '/f'
1757
file_id = file_path.replace('/', '_')+'-id'
1758
state.add(d, d_id, 'directory', fake_stat, null_sha)
1759
state.add(file_path, file_id, 'file', fake_stat, null_sha)
1761
expected = ['', '', 'a',
1762
'a/a', 'a/a/a', 'a/a/a/a',
1763
'a/a/a/a-a', 'a/a/a-a', 'a/a-a', 'a-a',
1765
split = lambda p:p.split('/')
1766
self.assertEqual(sorted(expected, key=split), expected)
1767
dirblock_names = [d[0] for d in state._dirblocks]
1768
self.assertEqual(expected, dirblock_names)
1770
def test_set_parent_trees_correct_order(self):
1771
"""After calling set_parent_trees() we should maintain the order."""
1772
dirs = ['a', 'a-a', 'a/a']
1774
state = dirstate.DirState.initialize('dirstate')
1775
self.addCleanup(state.unlock)
1777
fake_stat = os.stat('dirstate')
1779
d_id = d.replace('/', '_')+'-id'
1780
file_path = d + '/f'
1781
file_id = file_path.replace('/', '_')+'-id'
1782
state.add(d, d_id, 'directory', fake_stat, null_sha)
1783
state.add(file_path, file_id, 'file', fake_stat, null_sha)
1785
expected = ['', '', 'a', 'a/a', 'a-a']
1786
dirblock_names = [d[0] for d in state._dirblocks]
1787
self.assertEqual(expected, dirblock_names)
1789
# *really* cheesy way to just get an empty tree
1790
repo = self.make_repository('repo')
1791
empty_tree = repo.revision_tree(_mod_revision.NULL_REVISION)
1792
state.set_parent_trees([('null:', empty_tree)], [])
1794
dirblock_names = [d[0] for d in state._dirblocks]
1795
self.assertEqual(expected, dirblock_names)
1798
class InstrumentedDirState(dirstate.DirState):
1799
"""An DirState with instrumented sha1 functionality."""
1801
def __init__(self, path, sha1_provider, worth_saving_limit=0):
1802
super(InstrumentedDirState, self).__init__(path, sha1_provider,
1803
worth_saving_limit=worth_saving_limit)
1804
self._time_offset = 0
1806
# member is dynamically set in DirState.__init__ to turn on trace
1807
self._sha1_provider = sha1_provider
1808
self._sha1_file = self._sha1_file_and_log
1810
def _sha_cutoff_time(self):
1811
timestamp = super(InstrumentedDirState, self)._sha_cutoff_time()
1812
self._cutoff_time = timestamp + self._time_offset
1814
def _sha1_file_and_log(self, abspath):
1815
self._log.append(('sha1', abspath))
1816
return self._sha1_provider.sha1(abspath)
1818
def _read_link(self, abspath, old_link):
1819
self._log.append(('read_link', abspath, old_link))
1820
return super(InstrumentedDirState, self)._read_link(abspath, old_link)
1822
def _lstat(self, abspath, entry):
1823
self._log.append(('lstat', abspath))
1824
return super(InstrumentedDirState, self)._lstat(abspath, entry)
1826
def _is_executable(self, mode, old_executable):
1827
self._log.append(('is_exec', mode, old_executable))
1828
return super(InstrumentedDirState, self)._is_executable(mode,
1831
def adjust_time(self, secs):
1832
"""Move the clock forward or back.
1834
:param secs: The amount to adjust the clock by. Positive values make it
1835
seem as if we are in the future, negative values make it seem like we
1838
self._time_offset += secs
1839
self._cutoff_time = None
1842
class _FakeStat(object):
1843
"""A class with the same attributes as a real stat result."""
1845
def __init__(self, size, mtime, ctime, dev, ino, mode):
1847
self.st_mtime = mtime
1848
self.st_ctime = ctime
1855
return _FakeStat(st.st_size, st.st_mtime, st.st_ctime, st.st_dev,
1856
st.st_ino, st.st_mode)
1859
class TestPackStat(tests.TestCaseWithTransport):
1861
def assertPackStat(self, expected, stat_value):
1862
"""Check the packed and serialized form of a stat value."""
1863
self.assertEqual(expected, dirstate.pack_stat(stat_value))
1865
def test_pack_stat_int(self):
1866
st = _FakeStat(6859L, 1172758614, 1172758617, 777L, 6499538L, 0100644)
1867
# Make sure that all parameters have an impact on the packed stat.
1868
self.assertPackStat('AAAay0Xm4FZF5uBZAAADCQBjLNIAAIGk', st)
1871
self.assertPackStat('AAAbWEXm4FZF5uBZAAADCQBjLNIAAIGk', st)
1872
st.st_mtime = 1172758620
1874
self.assertPackStat('AAAbWEXm4FxF5uBZAAADCQBjLNIAAIGk', st)
1875
st.st_ctime = 1172758630
1877
self.assertPackStat('AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
1880
self.assertPackStat('AAAbWEXm4FxF5uBmAAADeABjLNIAAIGk', st)
1881
st.st_ino = 6499540L
1883
self.assertPackStat('AAAbWEXm4FxF5uBmAAADeABjLNQAAIGk', st)
1884
st.st_mode = 0100744
1886
self.assertPackStat('AAAbWEXm4FxF5uBmAAADeABjLNQAAIHk', st)
1888
def test_pack_stat_float(self):
1889
"""On some platforms mtime and ctime are floats.
1891
Make sure we don't get warnings or errors, and that we ignore changes <
1894
st = _FakeStat(7000L, 1172758614.0, 1172758617.0,
1895
777L, 6499538L, 0100644)
1896
# These should all be the same as the integer counterparts
1897
self.assertPackStat('AAAbWEXm4FZF5uBZAAADCQBjLNIAAIGk', st)
1898
st.st_mtime = 1172758620.0
1900
self.assertPackStat('AAAbWEXm4FxF5uBZAAADCQBjLNIAAIGk', st)
1901
st.st_ctime = 1172758630.0
1903
self.assertPackStat('AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
1904
# fractional seconds are discarded, so no change from above
1905
st.st_mtime = 1172758620.453
1906
self.assertPackStat('AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
1907
st.st_ctime = 1172758630.228
1908
self.assertPackStat('AAAbWEXm4FxF5uBmAAADCQBjLNIAAIGk', st)
1911
class TestBisect(TestCaseWithDirState):
1912
"""Test the ability to bisect into the disk format."""
1914
def assertBisect(self, expected_map, map_keys, state, paths):
1915
"""Assert that bisecting for paths returns the right result.
1917
:param expected_map: A map from key => entry value
1918
:param map_keys: The keys to expect for each path
1919
:param state: The DirState object.
1920
:param paths: A list of paths, these will automatically be split into
1921
(dir, name) tuples, and sorted according to how _bisect
1924
result = state._bisect(paths)
1925
# For now, results are just returned in whatever order we read them.
1926
# We could sort by (dir, name, file_id) or something like that, but in
1927
# the end it would still be fairly arbitrary, and we don't want the
1928
# extra overhead if we can avoid it. So sort everything to make sure
1930
self.assertEqual(len(map_keys), len(paths))
1932
for path, keys in zip(paths, map_keys):
1934
# This should not be present in the output
1936
expected[path] = sorted(expected_map[k] for k in keys)
1938
# The returned values are just arranged randomly based on when they
1939
# were read, for testing, make sure it is properly sorted.
1943
self.assertEqual(expected, result)
1945
def assertBisectDirBlocks(self, expected_map, map_keys, state, paths):
1946
"""Assert that bisecting for dirbblocks returns the right result.
1948
:param expected_map: A map from key => expected values
1949
:param map_keys: A nested list of paths we expect to be returned.
1950
Something like [['a', 'b', 'f'], ['b/c', 'b/d']]
1951
:param state: The DirState object.
1952
:param paths: A list of directories
1954
result = state._bisect_dirblocks(paths)
1955
self.assertEqual(len(map_keys), len(paths))
1957
for path, keys in zip(paths, map_keys):
1959
# This should not be present in the output
1961
expected[path] = sorted(expected_map[k] for k in keys)
1965
self.assertEqual(expected, result)
1967
def assertBisectRecursive(self, expected_map, map_keys, state, paths):
1968
"""Assert the return value of a recursive bisection.
1970
:param expected_map: A map from key => entry value
1971
:param map_keys: A list of paths we expect to be returned.
1972
Something like ['a', 'b', 'f', 'b/d', 'b/d2']
1973
:param state: The DirState object.
1974
:param paths: A list of files and directories. It will be broken up
1975
into (dir, name) pairs and sorted before calling _bisect_recursive.
1978
for key in map_keys:
1979
entry = expected_map[key]
1980
dir_name_id, trees_info = entry
1981
expected[dir_name_id] = trees_info
1983
result = state._bisect_recursive(paths)
1985
self.assertEqual(expected, result)
1987
def test_bisect_each(self):
1988
"""Find a single record using bisect."""
1989
tree, state, expected = self.create_basic_dirstate()
1991
# Bisect should return the rows for the specified files.
1992
self.assertBisect(expected, [['']], state, [''])
1993
self.assertBisect(expected, [['a']], state, ['a'])
1994
self.assertBisect(expected, [['b']], state, ['b'])
1995
self.assertBisect(expected, [['b/c']], state, ['b/c'])
1996
self.assertBisect(expected, [['b/d']], state, ['b/d'])
1997
self.assertBisect(expected, [['b/d/e']], state, ['b/d/e'])
1998
self.assertBisect(expected, [['b-c']], state, ['b-c'])
1999
self.assertBisect(expected, [['f']], state, ['f'])
2001
def test_bisect_multi(self):
2002
"""Bisect can be used to find multiple records at the same time."""
2003
tree, state, expected = self.create_basic_dirstate()
2004
# Bisect should be capable of finding multiple entries at the same time
2005
self.assertBisect(expected, [['a'], ['b'], ['f']],
2006
state, ['a', 'b', 'f'])
2007
self.assertBisect(expected, [['f'], ['b/d'], ['b/d/e']],
2008
state, ['f', 'b/d', 'b/d/e'])
2009
self.assertBisect(expected, [['b'], ['b-c'], ['b/c']],
2010
state, ['b', 'b-c', 'b/c'])
2012
def test_bisect_one_page(self):
2013
"""Test bisect when there is only 1 page to read"""
2014
tree, state, expected = self.create_basic_dirstate()
2015
state._bisect_page_size = 5000
2016
self.assertBisect(expected,[['']], state, [''])
2017
self.assertBisect(expected,[['a']], state, ['a'])
2018
self.assertBisect(expected,[['b']], state, ['b'])
2019
self.assertBisect(expected,[['b/c']], state, ['b/c'])
2020
self.assertBisect(expected,[['b/d']], state, ['b/d'])
2021
self.assertBisect(expected,[['b/d/e']], state, ['b/d/e'])
2022
self.assertBisect(expected,[['b-c']], state, ['b-c'])
2023
self.assertBisect(expected,[['f']], state, ['f'])
2024
self.assertBisect(expected,[['a'], ['b'], ['f']],
2025
state, ['a', 'b', 'f'])
2026
self.assertBisect(expected, [['b/d'], ['b/d/e'], ['f']],
2027
state, ['b/d', 'b/d/e', 'f'])
2028
self.assertBisect(expected, [['b'], ['b/c'], ['b-c']],
2029
state, ['b', 'b/c', 'b-c'])
2031
def test_bisect_duplicate_paths(self):
2032
"""When bisecting for a path, handle multiple entries."""
2033
tree, state, expected = self.create_duplicated_dirstate()
2035
# Now make sure that both records are properly returned.
2036
self.assertBisect(expected, [['']], state, [''])
2037
self.assertBisect(expected, [['a', 'a2']], state, ['a'])
2038
self.assertBisect(expected, [['b', 'b2']], state, ['b'])
2039
self.assertBisect(expected, [['b/c', 'b/c2']], state, ['b/c'])
2040
self.assertBisect(expected, [['b/d', 'b/d2']], state, ['b/d'])
2041
self.assertBisect(expected, [['b/d/e', 'b/d/e2']],
2043
self.assertBisect(expected, [['b-c', 'b-c2']], state, ['b-c'])
2044
self.assertBisect(expected, [['f', 'f2']], state, ['f'])
2046
def test_bisect_page_size_too_small(self):
2047
"""If the page size is too small, we will auto increase it."""
2048
tree, state, expected = self.create_basic_dirstate()
2049
state._bisect_page_size = 50
2050
self.assertBisect(expected, [None], state, ['b/e'])
2051
self.assertBisect(expected, [['a']], state, ['a'])
2052
self.assertBisect(expected, [['b']], state, ['b'])
2053
self.assertBisect(expected, [['b/c']], state, ['b/c'])
2054
self.assertBisect(expected, [['b/d']], state, ['b/d'])
2055
self.assertBisect(expected, [['b/d/e']], state, ['b/d/e'])
2056
self.assertBisect(expected, [['b-c']], state, ['b-c'])
2057
self.assertBisect(expected, [['f']], state, ['f'])
2059
def test_bisect_missing(self):
2060
"""Test that bisect return None if it cannot find a path."""
2061
tree, state, expected = self.create_basic_dirstate()
2062
self.assertBisect(expected, [None], state, ['foo'])
2063
self.assertBisect(expected, [None], state, ['b/foo'])
2064
self.assertBisect(expected, [None], state, ['bar/foo'])
2065
self.assertBisect(expected, [None], state, ['b-c/foo'])
2067
self.assertBisect(expected, [['a'], None, ['b/d']],
2068
state, ['a', 'foo', 'b/d'])
2070
def test_bisect_rename(self):
2071
"""Check that we find a renamed row."""
2072
tree, state, expected = self.create_renamed_dirstate()
2074
# Search for the pre and post renamed entries
2075
self.assertBisect(expected, [['a']], state, ['a'])
2076
self.assertBisect(expected, [['b/g']], state, ['b/g'])
2077
self.assertBisect(expected, [['b/d']], state, ['b/d'])
2078
self.assertBisect(expected, [['h']], state, ['h'])
2080
# What about b/d/e? shouldn't that also get 2 directory entries?
2081
self.assertBisect(expected, [['b/d/e']], state, ['b/d/e'])
2082
self.assertBisect(expected, [['h/e']], state, ['h/e'])
2084
def test_bisect_dirblocks(self):
2085
tree, state, expected = self.create_duplicated_dirstate()
2086
self.assertBisectDirBlocks(expected,
2087
[['', 'a', 'a2', 'b', 'b2', 'b-c', 'b-c2', 'f', 'f2']],
2089
self.assertBisectDirBlocks(expected,
2090
[['b/c', 'b/c2', 'b/d', 'b/d2']], state, ['b'])
2091
self.assertBisectDirBlocks(expected,
2092
[['b/d/e', 'b/d/e2']], state, ['b/d'])
2093
self.assertBisectDirBlocks(expected,
2094
[['', 'a', 'a2', 'b', 'b2', 'b-c', 'b-c2', 'f', 'f2'],
2095
['b/c', 'b/c2', 'b/d', 'b/d2'],
2096
['b/d/e', 'b/d/e2'],
2097
], state, ['', 'b', 'b/d'])
2099
def test_bisect_dirblocks_missing(self):
2100
tree, state, expected = self.create_basic_dirstate()
2101
self.assertBisectDirBlocks(expected, [['b/d/e'], None],
2102
state, ['b/d', 'b/e'])
2103
# Files don't show up in this search
2104
self.assertBisectDirBlocks(expected, [None], state, ['a'])
2105
self.assertBisectDirBlocks(expected, [None], state, ['b/c'])
2106
self.assertBisectDirBlocks(expected, [None], state, ['c'])
2107
self.assertBisectDirBlocks(expected, [None], state, ['b/d/e'])
2108
self.assertBisectDirBlocks(expected, [None], state, ['f'])
2110
def test_bisect_recursive_each(self):
2111
tree, state, expected = self.create_basic_dirstate()
2112
self.assertBisectRecursive(expected, ['a'], state, ['a'])
2113
self.assertBisectRecursive(expected, ['b/c'], state, ['b/c'])
2114
self.assertBisectRecursive(expected, ['b/d/e'], state, ['b/d/e'])
2115
self.assertBisectRecursive(expected, ['b-c'], state, ['b-c'])
2116
self.assertBisectRecursive(expected, ['b/d', 'b/d/e'],
2118
self.assertBisectRecursive(expected, ['b', 'b/c', 'b/d', 'b/d/e'],
2120
self.assertBisectRecursive(expected, ['', 'a', 'b', 'b-c', 'f', 'b/c',
2124
def test_bisect_recursive_multiple(self):
2125
tree, state, expected = self.create_basic_dirstate()
2126
self.assertBisectRecursive(expected, ['a', 'b/c'], state, ['a', 'b/c'])
2127
self.assertBisectRecursive(expected, ['b/d', 'b/d/e'],
2128
state, ['b/d', 'b/d/e'])
2130
def test_bisect_recursive_missing(self):
2131
tree, state, expected = self.create_basic_dirstate()
2132
self.assertBisectRecursive(expected, [], state, ['d'])
2133
self.assertBisectRecursive(expected, [], state, ['b/e'])
2134
self.assertBisectRecursive(expected, [], state, ['g'])
2135
self.assertBisectRecursive(expected, ['a'], state, ['a', 'g'])
2137
def test_bisect_recursive_renamed(self):
2138
tree, state, expected = self.create_renamed_dirstate()
2140
# Looking for either renamed item should find the other
2141
self.assertBisectRecursive(expected, ['a', 'b/g'], state, ['a'])
2142
self.assertBisectRecursive(expected, ['a', 'b/g'], state, ['b/g'])
2143
# Looking in the containing directory should find the rename target,
2144
# and anything in a subdir of the renamed target.
2145
self.assertBisectRecursive(expected, ['a', 'b', 'b/c', 'b/d',
2146
'b/d/e', 'b/g', 'h', 'h/e'],
2150
class TestDirstateValidation(TestCaseWithDirState):
2152
def test_validate_correct_dirstate(self):
2153
state = self.create_complex_dirstate()
2156
# and make sure we can also validate with a read lock
2163
def test_dirblock_not_sorted(self):
2164
tree, state, expected = self.create_renamed_dirstate()
2165
state._read_dirblocks_if_needed()
2166
last_dirblock = state._dirblocks[-1]
2167
# we're appending to the dirblock, but this name comes before some of
2168
# the existing names; that's wrong
2169
last_dirblock[1].append(
2170
(('h', 'aaaa', 'a-id'),
2171
[('a', '', 0, False, ''),
2172
('a', '', 0, False, '')]))
2173
e = self.assertRaises(AssertionError,
2175
self.assertContainsRe(str(e), 'not sorted')
2177
def test_dirblock_name_mismatch(self):
2178
tree, state, expected = self.create_renamed_dirstate()
2179
state._read_dirblocks_if_needed()
2180
last_dirblock = state._dirblocks[-1]
2181
# add an entry with the wrong directory name
2182
last_dirblock[1].append(
2184
[('a', '', 0, False, ''),
2185
('a', '', 0, False, '')]))
2186
e = self.assertRaises(AssertionError,
2188
self.assertContainsRe(str(e),
2189
"doesn't match directory name")
2191
def test_dirblock_missing_rename(self):
2192
tree, state, expected = self.create_renamed_dirstate()
2193
state._read_dirblocks_if_needed()
2194
last_dirblock = state._dirblocks[-1]
2195
# make another entry for a-id, without a correct 'r' pointer to
2196
# the real occurrence in the working tree
2197
last_dirblock[1].append(
2198
(('h', 'z', 'a-id'),
2199
[('a', '', 0, False, ''),
2200
('a', '', 0, False, '')]))
2201
e = self.assertRaises(AssertionError,
2203
self.assertContainsRe(str(e),
2204
'file a-id is absent in row')
2207
class TestDirstateTreeReference(TestCaseWithDirState):
2209
def test_reference_revision_is_none(self):
2210
tree = self.make_branch_and_tree('tree', format='dirstate-with-subtree')
2211
subtree = self.make_branch_and_tree('tree/subtree',
2212
format='dirstate-with-subtree')
2213
subtree.set_root_id('subtree')
2214
tree.add_reference(subtree)
2216
state = dirstate.DirState.from_tree(tree, 'dirstate')
2217
key = ('', 'subtree', 'subtree')
2218
expected = ('', [(key,
2219
[('t', '', 0, False, 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx')])])
2222
self.assertEqual(expected, state._find_block(key))
2227
class TestDiscardMergeParents(TestCaseWithDirState):
2229
def test_discard_no_parents(self):
2230
# This should be a no-op
2231
state = self.create_empty_dirstate()
2232
self.addCleanup(state.unlock)
2233
state._discard_merge_parents()
2236
def test_discard_one_parent(self):
2238
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
2239
root_entry_direntry = ('', '', 'a-root-value'), [
2240
('d', '', 0, False, packed_stat),
2241
('d', '', 0, False, packed_stat),
2244
dirblocks.append(('', [root_entry_direntry]))
2245
dirblocks.append(('', []))
2247
state = self.create_empty_dirstate()
2248
self.addCleanup(state.unlock)
2249
state._set_data(['parent-id'], dirblocks[:])
2252
state._discard_merge_parents()
2254
self.assertEqual(dirblocks, state._dirblocks)
2256
def test_discard_simple(self):
2258
packed_stat = 'AAAAREUHaIpFB2iKAAADAQAtkqUAAIGk'
2259
root_entry_direntry = ('', '', 'a-root-value'), [
2260
('d', '', 0, False, packed_stat),
2261
('d', '', 0, False, packed_stat),
2262
('d', '', 0, False, packed_stat),
2264
expected_root_entry_direntry = ('', '', 'a-root-value'), [
2265
('d', '', 0, False, packed_stat),
2266
('d', '', 0, False, packed_stat),
2269
dirblocks.append(('', [root_entry_direntry]))
2270
dirblocks.append(('', []))
2272
state = self.create_empty_dirstate()
2273
self.addCleanup(state.unlock)
2274
state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2277
# This should strip of the extra column
2278
state._discard_merge_parents()
2280
expected_dirblocks = [('', [expected_root_entry_direntry]), ('', [])]
2281
self.assertEqual(expected_dirblocks, state._dirblocks)
2283
def test_discard_absent(self):
2284
"""If entries are only in a merge, discard should remove the entries"""
2285
null_stat = dirstate.DirState.NULLSTAT
2286
present_dir = ('d', '', 0, False, null_stat)
2287
present_file = ('f', '', 0, False, null_stat)
2288
absent = dirstate.DirState.NULL_PARENT_DETAILS
2289
root_key = ('', '', 'a-root-value')
2290
file_in_root_key = ('', 'file-in-root', 'a-file-id')
2291
file_in_merged_key = ('', 'file-in-merged', 'b-file-id')
2292
dirblocks = [('', [(root_key, [present_dir, present_dir, present_dir])]),
2293
('', [(file_in_merged_key,
2294
[absent, absent, present_file]),
2296
[present_file, present_file, present_file]),
2300
state = self.create_empty_dirstate()
2301
self.addCleanup(state.unlock)
2302
state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2305
exp_dirblocks = [('', [(root_key, [present_dir, present_dir])]),
2306
('', [(file_in_root_key,
2307
[present_file, present_file]),
2310
state._discard_merge_parents()
2312
self.assertEqual(exp_dirblocks, state._dirblocks)
2314
def test_discard_renamed(self):
2315
null_stat = dirstate.DirState.NULLSTAT
2316
present_dir = ('d', '', 0, False, null_stat)
2317
present_file = ('f', '', 0, False, null_stat)
2318
absent = dirstate.DirState.NULL_PARENT_DETAILS
2319
root_key = ('', '', 'a-root-value')
2320
file_in_root_key = ('', 'file-in-root', 'a-file-id')
2321
# Renamed relative to parent
2322
file_rename_s_key = ('', 'file-s', 'b-file-id')
2323
file_rename_t_key = ('', 'file-t', 'b-file-id')
2324
# And one that is renamed between the parents, but absent in this
2325
key_in_1 = ('', 'file-in-1', 'c-file-id')
2326
key_in_2 = ('', 'file-in-2', 'c-file-id')
2329
('', [(root_key, [present_dir, present_dir, present_dir])]),
2331
[absent, present_file, ('r', 'file-in-2', 'c-file-id')]),
2333
[absent, ('r', 'file-in-1', 'c-file-id'), present_file]),
2335
[present_file, present_file, present_file]),
2337
[('r', 'file-t', 'b-file-id'), absent, present_file]),
2339
[present_file, absent, ('r', 'file-s', 'b-file-id')]),
2343
('', [(root_key, [present_dir, present_dir])]),
2344
('', [(key_in_1, [absent, present_file]),
2345
(file_in_root_key, [present_file, present_file]),
2346
(file_rename_t_key, [present_file, absent]),
2349
state = self.create_empty_dirstate()
2350
self.addCleanup(state.unlock)
2351
state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2354
state._discard_merge_parents()
2356
self.assertEqual(exp_dirblocks, state._dirblocks)
2358
def test_discard_all_subdir(self):
2359
null_stat = dirstate.DirState.NULLSTAT
2360
present_dir = ('d', '', 0, False, null_stat)
2361
present_file = ('f', '', 0, False, null_stat)
2362
absent = dirstate.DirState.NULL_PARENT_DETAILS
2363
root_key = ('', '', 'a-root-value')
2364
subdir_key = ('', 'sub', 'dir-id')
2365
child1_key = ('sub', 'child1', 'child1-id')
2366
child2_key = ('sub', 'child2', 'child2-id')
2367
child3_key = ('sub', 'child3', 'child3-id')
2370
('', [(root_key, [present_dir, present_dir, present_dir])]),
2371
('', [(subdir_key, [present_dir, present_dir, present_dir])]),
2372
('sub', [(child1_key, [absent, absent, present_file]),
2373
(child2_key, [absent, absent, present_file]),
2374
(child3_key, [absent, absent, present_file]),
2378
('', [(root_key, [present_dir, present_dir])]),
2379
('', [(subdir_key, [present_dir, present_dir])]),
2382
state = self.create_empty_dirstate()
2383
self.addCleanup(state.unlock)
2384
state._set_data(['parent-id', 'merged-id'], dirblocks[:])
2387
state._discard_merge_parents()
2389
self.assertEqual(exp_dirblocks, state._dirblocks)
2392
class Test_InvEntryToDetails(tests.TestCase):
2394
def assertDetails(self, expected, inv_entry):
2395
details = dirstate.DirState._inv_entry_to_details(inv_entry)
2396
self.assertEqual(expected, details)
2397
# details should always allow join() and always be a plain str when
2399
(minikind, fingerprint, size, executable, tree_data) = details
2400
self.assertIsInstance(minikind, str)
2401
self.assertIsInstance(fingerprint, str)
2402
self.assertIsInstance(tree_data, str)
2404
def test_unicode_symlink(self):
2405
inv_entry = inventory.InventoryLink('link-file-id',
2406
u'nam\N{Euro Sign}e',
2408
inv_entry.revision = 'link-revision-id'
2409
target = u'link-targ\N{Euro Sign}t'
2410
inv_entry.symlink_target = target
2411
self.assertDetails(('l', target.encode('UTF-8'), 0, False,
2412
'link-revision-id'), inv_entry)
2415
class TestSHA1Provider(tests.TestCaseInTempDir):
2417
def test_sha1provider_is_an_interface(self):
2418
p = dirstate.SHA1Provider()
2419
self.assertRaises(NotImplementedError, p.sha1, "foo")
2420
self.assertRaises(NotImplementedError, p.stat_and_sha1, "foo")
2422
def test_defaultsha1provider_sha1(self):
2423
text = 'test\r\nwith\nall\rpossible line endings\r\n'
2424
self.build_tree_contents([('foo', text)])
2425
expected_sha = osutils.sha_string(text)
2426
p = dirstate.DefaultSHA1Provider()
2427
self.assertEqual(expected_sha, p.sha1('foo'))
2429
def test_defaultsha1provider_stat_and_sha1(self):
2430
text = 'test\r\nwith\nall\rpossible line endings\r\n'
2431
self.build_tree_contents([('foo', text)])
2432
expected_sha = osutils.sha_string(text)
2433
p = dirstate.DefaultSHA1Provider()
2434
statvalue, sha1 = p.stat_and_sha1('foo')
2435
self.assertTrue(len(statvalue) >= 10)
2436
self.assertEqual(len(text), statvalue.st_size)
2437
self.assertEqual(expected_sha, sha1)
2440
class _Repo(object):
2441
"""A minimal api to get InventoryRevisionTree to work."""
2444
default_format = bzrdir.format_registry.make_bzrdir('default')
2445
self._format = default_format.repository_format
2447
def lock_read(self):
2454
class TestUpdateBasisByDelta(tests.TestCase):
2456
def path_to_ie(self, path, file_id, rev_id, dir_ids):
2457
if path.endswith('/'):
2462
dirname, basename = osutils.split(path)
2464
dir_id = dir_ids[dirname]
2466
dir_id = osutils.basename(dirname) + '-id'
2468
ie = inventory.InventoryDirectory(file_id, basename, dir_id)
2469
dir_ids[path] = file_id
2471
ie = inventory.InventoryFile(file_id, basename, dir_id)
2474
ie.revision = rev_id
2477
def create_tree_from_shape(self, rev_id, shape):
2478
dir_ids = {'': 'root-id'}
2479
inv = inventory.Inventory('root-id', rev_id)
2480
for path, file_id in shape:
2482
# Replace the root entry
2483
del inv._byid[inv.root.file_id]
2484
inv.root.file_id = file_id
2485
inv._byid[file_id] = inv.root
2486
dir_ids[''] = file_id
2488
inv.add(self.path_to_ie(path, file_id, rev_id, dir_ids))
2489
return revisiontree.InventoryRevisionTree(_Repo(), inv, rev_id)
2491
def create_empty_dirstate(self):
2492
fd, path = tempfile.mkstemp(prefix='bzr-dirstate')
2493
self.addCleanup(os.remove, path)
2495
state = dirstate.DirState.initialize(path)
2496
self.addCleanup(state.unlock)
2499
def create_inv_delta(self, delta, rev_id):
2500
"""Translate a 'delta shape' into an actual InventoryDelta"""
2501
dir_ids = {'': 'root-id'}
2503
for old_path, new_path, file_id in delta:
2504
if old_path is not None and old_path.endswith('/'):
2505
# Don't have to actually do anything for this, because only
2506
# new_path creates InventoryEntries
2507
old_path = old_path[:-1]
2508
if new_path is None: # Delete
2509
inv_delta.append((old_path, None, file_id, None))
2511
ie = self.path_to_ie(new_path, file_id, rev_id, dir_ids)
2512
inv_delta.append((old_path, new_path, file_id, ie))
2515
def assertUpdate(self, active, basis, target):
2516
"""Assert that update_basis_by_delta works how we want.
2518
Set up a DirState object with active_shape for tree 0, basis_shape for
2519
tree 1. Then apply the delta from basis_shape to target_shape,
2520
and assert that the DirState is still valid, and that its stored
2521
content matches the target_shape.
2523
active_tree = self.create_tree_from_shape('active', active)
2524
basis_tree = self.create_tree_from_shape('basis', basis)
2525
target_tree = self.create_tree_from_shape('target', target)
2526
state = self.create_empty_dirstate()
2527
state.set_state_from_scratch(active_tree.inventory,
2528
[('basis', basis_tree)], [])
2529
delta = target_tree.inventory._make_delta(basis_tree.inventory)
2530
state.update_basis_by_delta(delta, 'target')
2532
dirstate_tree = workingtree_4.DirStateRevisionTree(state,
2534
# The target now that delta has been applied should match the
2536
self.assertEqual([], list(dirstate_tree.iter_changes(target_tree)))
2537
# And the dirblock state should be identical to the state if we created
2539
state2 = self.create_empty_dirstate()
2540
state2.set_state_from_scratch(active_tree.inventory,
2541
[('target', target_tree)], [])
2542
self.assertEqual(state2._dirblocks, state._dirblocks)
2545
def assertBadDelta(self, active, basis, delta):
2546
"""Test that we raise InconsistentDelta when appropriate.
2548
:param active: The active tree shape
2549
:param basis: The basis tree shape
2550
:param delta: A description of the delta to apply. Similar to the form
2551
for regular inventory deltas, but omitting the InventoryEntry.
2552
So adding a file is: (None, 'path', 'file-id')
2553
Adding a directory is: (None, 'path/', 'dir-id')
2554
Renaming a dir is: ('old/', 'new/', 'dir-id')
2557
active_tree = self.create_tree_from_shape('active', active)
2558
basis_tree = self.create_tree_from_shape('basis', basis)
2559
inv_delta = self.create_inv_delta(delta, 'target')
2560
state = self.create_empty_dirstate()
2561
state.set_state_from_scratch(active_tree.inventory,
2562
[('basis', basis_tree)], [])
2563
self.assertRaises(errors.InconsistentDelta,
2564
state.update_basis_by_delta, inv_delta, 'target')
2566
## state.update_basis_by_delta(inv_delta, 'target')
2567
## except errors.InconsistentDelta, e:
2568
## import pdb; pdb.set_trace()
2570
## import pdb; pdb.set_trace()
2571
self.assertTrue(state._changes_aborted)
2573
def test_remove_file_matching_active_state(self):
2574
state = self.assertUpdate(
2576
basis =[('file', 'file-id')],
2580
def test_remove_file_present_in_active_state(self):
2581
state = self.assertUpdate(
2582
active=[('file', 'file-id')],
2583
basis =[('file', 'file-id')],
2587
def test_remove_file_present_elsewhere_in_active_state(self):
2588
state = self.assertUpdate(
2589
active=[('other-file', 'file-id')],
2590
basis =[('file', 'file-id')],
2594
def test_remove_file_active_state_has_diff_file(self):
2595
state = self.assertUpdate(
2596
active=[('file', 'file-id-2')],
2597
basis =[('file', 'file-id')],
2601
def test_remove_file_active_state_has_diff_file_and_file_elsewhere(self):
2602
state = self.assertUpdate(
2603
active=[('file', 'file-id-2'),
2604
('other-file', 'file-id')],
2605
basis =[('file', 'file-id')],
2609
def test_add_file_matching_active_state(self):
2610
state = self.assertUpdate(
2611
active=[('file', 'file-id')],
2613
target=[('file', 'file-id')],
2616
def test_add_file_missing_in_active_state(self):
2617
state = self.assertUpdate(
2620
target=[('file', 'file-id')],
2623
def test_add_file_elsewhere_in_active_state(self):
2624
state = self.assertUpdate(
2625
active=[('other-file', 'file-id')],
2627
target=[('file', 'file-id')],
2630
def test_add_file_active_state_has_diff_file_and_file_elsewhere(self):
2631
state = self.assertUpdate(
2632
active=[('other-file', 'file-id'),
2633
('file', 'file-id-2')],
2635
target=[('file', 'file-id')],
2638
def test_rename_file_matching_active_state(self):
2639
state = self.assertUpdate(
2640
active=[('other-file', 'file-id')],
2641
basis =[('file', 'file-id')],
2642
target=[('other-file', 'file-id')],
2645
def test_rename_file_missing_in_active_state(self):
2646
state = self.assertUpdate(
2648
basis =[('file', 'file-id')],
2649
target=[('other-file', 'file-id')],
2652
def test_rename_file_present_elsewhere_in_active_state(self):
2653
state = self.assertUpdate(
2654
active=[('third', 'file-id')],
2655
basis =[('file', 'file-id')],
2656
target=[('other-file', 'file-id')],
2659
def test_rename_file_active_state_has_diff_source_file(self):
2660
state = self.assertUpdate(
2661
active=[('file', 'file-id-2')],
2662
basis =[('file', 'file-id')],
2663
target=[('other-file', 'file-id')],
2666
def test_rename_file_active_state_has_diff_target_file(self):
2667
state = self.assertUpdate(
2668
active=[('other-file', 'file-id-2')],
2669
basis =[('file', 'file-id')],
2670
target=[('other-file', 'file-id')],
2673
def test_rename_file_active_has_swapped_files(self):
2674
state = self.assertUpdate(
2675
active=[('file', 'file-id'),
2676
('other-file', 'file-id-2')],
2677
basis= [('file', 'file-id'),
2678
('other-file', 'file-id-2')],
2679
target=[('file', 'file-id-2'),
2680
('other-file', 'file-id')])
2682
def test_rename_file_basis_has_swapped_files(self):
2683
state = self.assertUpdate(
2684
active=[('file', 'file-id'),
2685
('other-file', 'file-id-2')],
2686
basis= [('file', 'file-id-2'),
2687
('other-file', 'file-id')],
2688
target=[('file', 'file-id'),
2689
('other-file', 'file-id-2')])
2691
def test_rename_directory_with_contents(self):
2692
state = self.assertUpdate( # active matches basis
2693
active=[('dir1/', 'dir-id'),
2694
('dir1/file', 'file-id')],
2695
basis= [('dir1/', 'dir-id'),
2696
('dir1/file', 'file-id')],
2697
target=[('dir2/', 'dir-id'),
2698
('dir2/file', 'file-id')])
2699
state = self.assertUpdate( # active matches target
2700
active=[('dir2/', 'dir-id'),
2701
('dir2/file', 'file-id')],
2702
basis= [('dir1/', 'dir-id'),
2703
('dir1/file', 'file-id')],
2704
target=[('dir2/', 'dir-id'),
2705
('dir2/file', 'file-id')])
2706
state = self.assertUpdate( # active empty
2708
basis= [('dir1/', 'dir-id'),
2709
('dir1/file', 'file-id')],
2710
target=[('dir2/', 'dir-id'),
2711
('dir2/file', 'file-id')])
2712
state = self.assertUpdate( # active present at other location
2713
active=[('dir3/', 'dir-id'),
2714
('dir3/file', 'file-id')],
2715
basis= [('dir1/', 'dir-id'),
2716
('dir1/file', 'file-id')],
2717
target=[('dir2/', 'dir-id'),
2718
('dir2/file', 'file-id')])
2719
state = self.assertUpdate( # active has different ids
2720
active=[('dir1/', 'dir1-id'),
2721
('dir1/file', 'file1-id'),
2722
('dir2/', 'dir2-id'),
2723
('dir2/file', 'file2-id')],
2724
basis= [('dir1/', 'dir-id'),
2725
('dir1/file', 'file-id')],
2726
target=[('dir2/', 'dir-id'),
2727
('dir2/file', 'file-id')])
2729
def test_invalid_file_not_present(self):
2730
state = self.assertBadDelta(
2731
active=[('file', 'file-id')],
2732
basis= [('file', 'file-id')],
2733
delta=[('other-file', 'file', 'file-id')])
2735
def test_invalid_new_id_same_path(self):
2736
# The bad entry comes after
2737
state = self.assertBadDelta(
2738
active=[('file', 'file-id')],
2739
basis= [('file', 'file-id')],
2740
delta=[(None, 'file', 'file-id-2')])
2741
# The bad entry comes first
2742
state = self.assertBadDelta(
2743
active=[('file', 'file-id-2')],
2744
basis=[('file', 'file-id-2')],
2745
delta=[(None, 'file', 'file-id')])
2747
def test_invalid_existing_id(self):
2748
state = self.assertBadDelta(
2749
active=[('file', 'file-id')],
2750
basis= [('file', 'file-id')],
2751
delta=[(None, 'file', 'file-id')])
2753
def test_invalid_parent_missing(self):
2754
state = self.assertBadDelta(
2757
delta=[(None, 'path/path2', 'file-id')])
2758
# Note: we force the active tree to have the directory, by knowing how
2759
# path_to_ie handles entries with missing parents
2760
state = self.assertBadDelta(
2761
active=[('path/', 'path-id')],
2763
delta=[(None, 'path/path2', 'file-id')])
2764
state = self.assertBadDelta(
2765
active=[('path/', 'path-id'),
2766
('path/path2', 'file-id')],
2768
delta=[(None, 'path/path2', 'file-id')])
2770
def test_renamed_dir_same_path(self):
2771
# We replace the parent directory, with another parent dir. But the C
2772
# file doesn't look like it has been moved.
2773
state = self.assertUpdate(# Same as basis
2774
active=[('dir/', 'A-id'),
2776
basis= [('dir/', 'A-id'),
2778
target=[('dir/', 'C-id'),
2780
state = self.assertUpdate(# Same as target
2781
active=[('dir/', 'C-id'),
2783
basis= [('dir/', 'A-id'),
2785
target=[('dir/', 'C-id'),
2787
state = self.assertUpdate(# empty active
2789
basis= [('dir/', 'A-id'),
2791
target=[('dir/', 'C-id'),
2793
state = self.assertUpdate(# different active
2794
active=[('dir/', 'D-id'),
2796
basis= [('dir/', 'A-id'),
2798
target=[('dir/', 'C-id'),
2801
def test_parent_child_swap(self):
2802
state = self.assertUpdate(# Same as basis
2803
active=[('A/', 'A-id'),
2806
basis= [('A/', 'A-id'),
2809
target=[('A/', 'B-id'),
2812
state = self.assertUpdate(# Same as target
2813
active=[('A/', 'B-id'),
2816
basis= [('A/', 'A-id'),
2819
target=[('A/', 'B-id'),
2822
state = self.assertUpdate(# empty active
2824
basis= [('A/', 'A-id'),
2827
target=[('A/', 'B-id'),
2830
state = self.assertUpdate(# different active
2831
active=[('D/', 'A-id'),
2834
basis= [('A/', 'A-id'),
2837
target=[('A/', 'B-id'),
2841
def test_change_root_id(self):
2842
state = self.assertUpdate( # same as basis
2843
active=[('', 'root-id'),
2844
('file', 'file-id')],
2845
basis= [('', 'root-id'),
2846
('file', 'file-id')],
2847
target=[('', 'target-root-id'),
2848
('file', 'file-id')])
2849
state = self.assertUpdate( # same as target
2850
active=[('', 'target-root-id'),
2851
('file', 'file-id')],
2852
basis= [('', 'root-id'),
2853
('file', 'file-id')],
2854
target=[('', 'target-root-id'),
2855
('file', 'root-id')])
2856
state = self.assertUpdate( # all different
2857
active=[('', 'active-root-id'),
2858
('file', 'file-id')],
2859
basis= [('', 'root-id'),
2860
('file', 'file-id')],
2861
target=[('', 'target-root-id'),
2862
('file', 'root-id')])
2864
def test_change_file_absent_in_active(self):
2865
state = self.assertUpdate(
2867
basis= [('file', 'file-id')],
2868
target=[('file', 'file-id')])
2870
def test_invalid_changed_file(self):
2871
state = self.assertBadDelta( # Not present in basis
2872
active=[('file', 'file-id')],
2874
delta=[('file', 'file', 'file-id')])
2875
state = self.assertBadDelta( # present at another location in basis
2876
active=[('file', 'file-id')],
2877
basis= [('other-file', 'file-id')],
2878
delta=[('file', 'file', 'file-id')])
added
removed
bzrlib/tests/test_dirstate.py
