/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_transform.py

  • Committer: Jelmer Vernooij
  • Date: 2018-11-11 04:08:32 UTC
  • mto: (7143.16.20 even-more-cleanups)
  • mto: This revision was merged to the branch mainline in revision 7175.
  • Revision ID: jelmer@jelmer.uk-20181111040832-nsljjynzzwmznf3h
Run autopep8.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_transform.py
185
185
                                  sha1=sha1)
186
186
        calls = []
187
187
        orig = self.wt._observed_sha1
 
188
 
188
189
        def _observed_sha1(*args):
189
190
            calls.append(args)
190
191
            orig(*args)
249
250
        transform._creation_mtime = creation_mtime = time.time() - 20.0
250
251
        transform.create_file([b'content-one'],
251
252
                              transform.create_path('one', root))
252
 
        time.sleep(1) # *ugly*
 
253
        time.sleep(1)  # *ugly*
253
254
        transform.create_file([b'content-two'],
254
255
                              transform.create_path('two', root))
255
256
        transform.apply()
259
260
        fo.close()
260
261
        # We only guarantee 2s resolution
261
262
        self.assertTrue(abs(creation_mtime - st1.st_mtime) < 2.0,
262
 
            "%s != %s within 2 seconds" % (creation_mtime, st1.st_mtime))
 
263
                        "%s != %s within 2 seconds" % (creation_mtime, st1.st_mtime))
263
264
        # But if we have more than that, all files should get the same result
264
265
        self.assertEqual(st1.st_mtime, st2.st_mtime)
265
266
 
640
641
 
641
642
        mangle_tree, root = self.get_transform()
642
643
        root = mangle_tree.root
643
 
        #swap names
 
644
        # swap names
644
645
        name1 = mangle_tree.trans_id_tree_path('name1')
645
646
        name2 = mangle_tree.trans_id_tree_path('name2')
646
647
        mangle_tree.adjust_path('name2', root, name1)
647
648
        mangle_tree.adjust_path('name1', root, name2)
648
649
 
649
 
        #tests for deleting parent directories
 
650
        # tests for deleting parent directories
650
651
        ddir = mangle_tree.trans_id_tree_path('dying_directory')
651
652
        mangle_tree.delete_contents(ddir)
652
653
        dfile = mangle_tree.trans_id_tree_path('dying_directory/dying_file')
655
656
        mfile = mangle_tree.trans_id_tree_path('dying_directory/moving_file')
656
657
        mangle_tree.adjust_path('mfile', root, mfile)
657
658
 
658
 
        #tests for adding parent directories
 
659
        # tests for adding parent directories
659
660
        newdir = mangle_tree.new_directory('new_directory', root, b'newdir')
660
661
        mfile2 = mangle_tree.trans_id_tree_path('moving_file2')
661
662
        mangle_tree.adjust_path('mfile2', newdir, mfile2)
684
685
    def test_both_rename(self):
685
686
        create_tree, root = self.get_transform()
686
687
        newdir = create_tree.new_directory('selftest', root, b'selftest-id')
687
 
        create_tree.new_file('blackbox.py', newdir, [b'hello1'], b'blackbox-id')
 
688
        create_tree.new_file('blackbox.py', newdir, [
 
689
                             b'hello1'], b'blackbox-id')
688
690
        create_tree.apply()
689
691
        mangle_tree, root = self.get_transform()
690
692
        selftest = mangle_tree.trans_id_tree_path('selftest')
705
707
        mangle_tree, root = self.get_transform()
706
708
        breezy = mangle_tree.trans_id_tree_path('breezy')
707
709
        tests = mangle_tree.trans_id_tree_path('breezy/tests')
708
 
        test_too_much = mangle_tree.trans_id_tree_path('breezy/tests/blackbox/test_too_much.py')
 
710
        test_too_much = mangle_tree.trans_id_tree_path(
 
711
            'breezy/tests/blackbox/test_too_much.py')
709
712
        mangle_tree.adjust_path('selftest', breezy, tests)
710
713
        mangle_tree.adjust_path('blackbox.py', tests, test_too_much)
711
714
        mangle_tree.set_executability(True, test_too_much)
719
722
        create_tree.apply()
720
723
        mangle_tree, root = self.get_transform()
721
724
        tests = mangle_tree.trans_id_tree_path('tests')
722
 
        test_too_much = mangle_tree.trans_id_tree_path('tests/test_too_much.py')
 
725
        test_too_much = mangle_tree.trans_id_tree_path(
 
726
            'tests/test_too_much.py')
723
727
        mangle_tree.adjust_path('selftest', root, tests)
724
728
        mangle_tree.adjust_path('blackbox.py', tests, test_too_much)
725
729
        mangle_tree.set_executability(True, test_too_much)
872
876
                                               'munchkincity',
873
877
                                               b'munchkincity-id')
874
878
        unversioned_parent2 = UnversionedParent('Versioned directory', 'oz',
875
 
                                               b'oz-id')
 
879
                                                b'oz-id')
876
880
        self.assertEqual(cooked_conflicts[3], unversioned_parent)
877
881
        parent_loop = ParentLoop('Cancelled move', 'oz/emeraldcity',
878
882
                                 'oz/emeraldcity', b'emerald-id', b'emerald-id')
901
905
                                         ' versioned, but has versioned'
902
906
                                         ' children.  Versioned directory.')
903
907
        self.assertEqualDiff(conflicts_s[4], "Conflict: can't delete oz because it"
904
 
                                         " is not empty.  Not deleting.")
 
908
                             " is not empty.  Not deleting.")
905
909
        self.assertEqual(conflicts_s[5], 'Conflict because oz is not'
906
910
                                         ' versioned, but has versioned'
907
911
                                         ' children.  Versioned directory.')
925
929
        tt = self.prepare_wrong_parent_kind()
926
930
        raw_conflicts = resolve_conflicts(tt)
927
931
        self.assertEqual({('non-directory parent', 'Created directory',
928
 
                         'new-3')}, raw_conflicts)
 
932
                           'new-3')}, raw_conflicts)
929
933
        cooked_conflicts = cook_conflicts(raw_conflicts, tt)
930
934
        self.assertEqual([NonDirectoryParent('Created directory', 'parent.new',
931
 
        b'parent-id')], cooked_conflicts)
 
935
                                             b'parent-id')], cooked_conflicts)
932
936
        tt.apply()
933
937
        self.assertFalse(self.wt.is_versioned('parent'))
934
938
        self.assertEqual(b'parent-id', self.wt.path2id('parent.new'))
944
948
        tt.create_file([b'contents'], parent_id)
945
949
        raw_conflicts = resolve_conflicts(tt)
946
950
        self.assertEqual({('non-directory parent', 'Created directory',
947
 
                         'new-3')}, raw_conflicts)
 
951
                           'new-3')}, raw_conflicts)
948
952
        tt.apply()
949
953
        self.assertFalse(self.wt.is_versioned('parent'))
950
954
        self.assertEqual(b'parent-id', self.wt.path2id('parent.new'))
1038
1042
        dir_id = rename_transform.trans_id_file_id(b'first-id')
1039
1043
        rename_transform.adjust_path('newname', dir_id, file_trans_id)
1040
1044
        e = self.assertRaises(errors.TransformRenameFailed,
1041
 
            rename_transform.apply)
1042
 
        # On nix looks like: 
 
1045
                              rename_transform.apply)
 
1046
        # On nix looks like:
1043
1047
        # "Failed to rename .../work/.bzr/checkout/limbo/new-1
1044
1048
        # to .../first-dir/newname: [Errno 13] Permission denied"
1045
1049
        # On windows looks like:
1046
 
        # "Failed to rename .../work/myfile to 
 
1050
        # "Failed to rename .../work/myfile to
1047
1051
        # .../work/.bzr/checkout/limbo/new-1: [Errno 13] Permission denied"
1048
1052
        # This test isn't concerned with exactly what the error looks like,
1049
1053
        # and the strerror will vary across OS and locales, but the assert
1103
1107
 
1104
1108
        stat_paths = []
1105
1109
        real_stat = os.stat
 
1110
 
1106
1111
        def instrumented_stat(path):
1107
1112
            stat_paths.append(path)
1108
1113
            return real_stat(path)
1118
1123
        bar2_id = transform.trans_id_tree_path('bar2')
1119
1124
        try:
1120
1125
            os.stat = instrumented_stat
1121
 
            transform.create_file([b'bar2 contents\n'], bar2_id, mode_id=bar1_id)
 
1126
            transform.create_file([b'bar2 contents\n'],
 
1127
                                  bar2_id, mode_id=bar1_id)
1122
1128
        finally:
1123
1129
            os.stat = real_stat
1124
1130
            transform.finalize()
1137
1143
            old = transform.trans_id_tree_path('old')
1138
1144
            transform.unversion_file(old)
1139
1145
            self.assertEqual([(b'id-1', ('old', None), False, (True, False),
1140
 
                (b'eert_toor', b'eert_toor'), ('old', 'old'), ('file', 'file'),
1141
 
                (True, True))], list(transform.iter_changes()))
 
1146
                               (b'eert_toor', b'eert_toor'), ('old',
 
1147
                                                              'old'), ('file', 'file'),
 
1148
                               (True, True))], list(transform.iter_changes()))
1142
1149
            transform.new_directory('new', root, b'id-1')
1143
1150
            self.assertEqual([(b'id-1', ('old', 'new'), True, (True, True),
1144
 
                (b'eert_toor', b'eert_toor'), ('old', 'new'),
1145
 
                ('file', 'directory'),
1146
 
                (True, False))], list(transform.iter_changes()))
 
1151
                               (b'eert_toor', b'eert_toor'), ('old', 'new'),
 
1152
                               ('file', 'directory'),
 
1153
                               (True, False))], list(transform.iter_changes()))
1147
1154
        finally:
1148
1155
            transform.finalize()
1149
1156
 
1157
1164
            old = transform.trans_id_tree_path('old')
1158
1165
            transform.version_file(b'id-1', old)
1159
1166
            self.assertEqual([(b'id-1', (None, 'old'), False, (False, True),
1160
 
                (b'eert_toor', b'eert_toor'), ('old', 'old'), ('file', 'file'),
1161
 
                (False, False))], list(transform.iter_changes()))
 
1167
                               (b'eert_toor', b'eert_toor'), ('old',
 
1168
                                                              'old'), ('file', 'file'),
 
1169
                               (False, False))], list(transform.iter_changes()))
1162
1170
        finally:
1163
1171
            transform.finalize()
1164
1172
 
1176
1184
            new = transform.trans_id_tree_path('new')
1177
1185
            self.assertEqual([], list(transform.iter_changes()))
1178
1186
 
1179
 
            #content deletion
 
1187
            # content deletion
1180
1188
            transform.delete_contents(old)
1181
1189
            self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1182
 
                (b'eert_toor', b'eert_toor'), ('old', 'old'), ('file', None),
1183
 
                (False, False))], list(transform.iter_changes()))
 
1190
                               (b'eert_toor', b'eert_toor'), ('old',
 
1191
                                                              'old'), ('file', None),
 
1192
                               (False, False))], list(transform.iter_changes()))
1184
1193
 
1185
 
            #content change
 
1194
            # content change
1186
1195
            transform.create_file([b'blah'], old)
1187
1196
            self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1188
 
                (b'eert_toor', b'eert_toor'), ('old', 'old'), ('file', 'file'),
1189
 
                (False, False))], list(transform.iter_changes()))
 
1197
                               (b'eert_toor', b'eert_toor'), ('old',
 
1198
                                                              'old'), ('file', 'file'),
 
1199
                               (False, False))], list(transform.iter_changes()))
1190
1200
            transform.cancel_deletion(old)
1191
1201
            self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1192
 
                (b'eert_toor', b'eert_toor'), ('old', 'old'), ('file', 'file'),
1193
 
                (False, False))], list(transform.iter_changes()))
 
1202
                               (b'eert_toor', b'eert_toor'), ('old',
 
1203
                                                              'old'), ('file', 'file'),
 
1204
                               (False, False))], list(transform.iter_changes()))
1194
1205
            transform.cancel_creation(old)
1195
1206
 
1196
1207
            # move file_id to a different file
1199
1210
            transform.version_file(b'id-1', new)
1200
1211
            transform.adjust_path('old', root, new)
1201
1212
            self.assertEqual([(b'id-1', ('old', 'old'), True, (True, True),
1202
 
                (b'eert_toor', b'eert_toor'), ('old', 'old'), ('file', 'file'),
1203
 
                (False, False))], list(transform.iter_changes()))
 
1213
                               (b'eert_toor', b'eert_toor'), ('old',
 
1214
                                                              'old'), ('file', 'file'),
 
1215
                               (False, False))], list(transform.iter_changes()))
1204
1216
            transform.cancel_versioning(new)
1205
1217
            transform._removed_id = set()
1206
1218
 
1207
 
            #execute bit
 
1219
            # execute bit
1208
1220
            self.assertEqual([], list(transform.iter_changes()))
1209
1221
            transform.set_executability(True, old)
1210
1222
            self.assertEqual([(b'id-1', ('old', 'old'), False, (True, True),
1211
 
                (b'eert_toor', b'eert_toor'), ('old', 'old'), ('file', 'file'),
1212
 
                (False, True))], list(transform.iter_changes()))
 
1223
                               (b'eert_toor', b'eert_toor'), ('old',
 
1224
                                                              'old'), ('file', 'file'),
 
1225
                               (False, True))], list(transform.iter_changes()))
1213
1226
            transform.set_executability(None, old)
1214
1227
 
1215
1228
            # filename
1217
1230
            transform.adjust_path('new', root, old)
1218
1231
            transform._new_parent = {}
1219
1232
            self.assertEqual([(b'id-1', ('old', 'new'), False, (True, True),
1220
 
                (b'eert_toor', b'eert_toor'), ('old', 'new'), ('file', 'file'),
1221
 
                (False, False))], list(transform.iter_changes()))
 
1233
                               (b'eert_toor', b'eert_toor'), ('old',
 
1234
                                                              'new'), ('file', 'file'),
 
1235
                               (False, False))], list(transform.iter_changes()))
1222
1236
            transform._new_name = {}
1223
1237
 
1224
1238
            # parent directory
1226
1240
            transform.adjust_path('new', subdir, old)
1227
1241
            transform._new_name = {}
1228
1242
            self.assertEqual([(b'id-1', ('old', 'subdir/old'), False,
1229
 
                (True, True), (b'eert_toor', b'subdir-id'), ('old', 'old'),
1230
 
                ('file', 'file'), (False, False))],
1231
 
                list(transform.iter_changes()))
 
1243
                               (True, True), (b'eert_toor',
 
1244
                                              b'subdir-id'), ('old', 'old'),
 
1245
                               ('file', 'file'), (False, False))],
 
1246
                             list(transform.iter_changes()))
1232
1247
            transform._new_path = {}
1233
1248
 
1234
1249
        finally:
1249
1264
        try:
1250
1265
            transform.delete_contents(transform.trans_id_file_id(b'id-1'))
1251
1266
            transform.set_executability(True,
1252
 
            transform.trans_id_file_id(b'id-2'))
 
1267
                                        transform.trans_id_file_id(b'id-2'))
1253
1268
            self.assertEqual([(b'id-1', (u'file1', u'file1'), True, (True, True),
1254
 
                (b'eert_toor', b'eert_toor'), ('file1', u'file1'),
1255
 
                ('file', None), (False, False)),
1256
 
                (b'id-2', (u'file2', u'file2'), False, (True, True),
1257
 
                (b'eert_toor', b'eert_toor'), ('file2', u'file2'),
1258
 
                ('file', 'file'), (False, True))],
1259
 
                list(transform.iter_changes()))
 
1269
                               (b'eert_toor', b'eert_toor'), ('file1', u'file1'),
 
1270
                               ('file', None), (False, False)),
 
1271
                              (b'id-2', (u'file2', u'file2'), False, (True, True),
 
1272
                               (b'eert_toor', b'eert_toor'), ('file2', u'file2'),
 
1273
                               ('file', 'file'), (False, True))],
 
1274
                             list(transform.iter_changes()))
1260
1275
        finally:
1261
1276
            transform.finalize()
1262
1277
 
1275
1290
        try:
1276
1291
            transform.adjust_path('flitter', root, floater)
1277
1292
            self.assertEqual([(b'floater-id', ('floater', 'flitter'), False,
1278
 
            (True, True), (b'toor_eert', b'toor_eert'), ('floater', 'flitter'),
1279
 
            (None, None), (False, False))], list(transform.iter_changes()))
 
1293
                               (True, True), (b'toor_eert',
 
1294
                                              b'toor_eert'), ('floater', 'flitter'),
 
1295
                               (None, None), (False, False))], list(transform.iter_changes()))
1280
1296
        finally:
1281
1297
            transform.finalize()
1282
1298
 
1630
1646
    def test_create_from_tree_bytes(self):
1631
1647
        """Provided lines are used instead of tree content."""
1632
1648
        tree1 = self.make_branch_and_tree('tree1')
1633
 
        self.build_tree_contents([('tree1/foo', b'bar'),])
 
1649
        self.build_tree_contents([('tree1/foo', b'bar'), ])
1634
1650
        tree1.add('foo', b'foo-id')
1635
1651
        tree2 = self.make_branch_and_tree('tree2')
1636
1652
        tt = TreeTransform(tree2)
1774
1790
        merge_modified = this.wt.merge_modified()
1775
1791
        self.assertSubset(merge_modified, modified)
1776
1792
        self.assertEqual(len(merge_modified), len(modified))
1777
 
        with open(this.wt.abspath(this.wt.id2path(b'a')), 'wb') as f: f.write(b'booga')
 
1793
        with open(this.wt.abspath(this.wt.id2path(b'a')), 'wb') as f:
 
1794
            f.write(b'booga')
1778
1795
        modified.pop(0)
1779
1796
        merge_modified = this.wt.merge_modified()
1780
1797
        self.assertSubset(merge_modified, modified)
1800
1817
            for link, target in (('e', e_target), ('f', f_target),
1801
1818
                                 ('g', g_target), ('h', h_target)):
1802
1819
                if target is not None:
1803
 
                    tg.tt.new_symlink(link, tg.root, target, link.encode('ascii'))
 
1820
                    tg.tt.new_symlink(link, tg.root, target,
 
1821
                                      link.encode('ascii'))
1804
1822
 
1805
1823
        for tg in this, base, other:
1806
1824
            tg.tt.apply()
1809
1827
        self.assertIs(os.path.islink(this.wt.abspath('b')), True)
1810
1828
        self.assertIs(os.path.isfile(this.wt.abspath('c')), True)
1811
1829
        for suffix in ('THIS', 'BASE', 'OTHER'):
1812
 
            self.assertEqual(os.readlink(this.wt.abspath('d.'+suffix)), suffix)
 
1830
            self.assertEqual(os.readlink(
 
1831
                this.wt.abspath('d.' + suffix)), suffix)
1813
1832
        self.assertIs(os.path.lexists(this.wt.abspath('d')), False)
1814
1833
        self.assertEqual(this.wt.id2path(b'd'), 'd.OTHER')
1815
1834
        self.assertEqual(this.wt.id2path(b'f'), 'f.THIS')
1896
1915
        os.mkdir('a')
1897
1916
        a = ControlDir.create_standalone_workingtree('a')
1898
1917
        os.mkdir('a/foo')
1899
 
        with open('a/foo/bar', 'wb') as f: f.write(b'contents')
 
1918
        with open('a/foo/bar', 'wb') as f:
 
1919
            f.write(b'contents')
1900
1920
        os.symlink('a/foo/bar', 'a/foo/baz')
1901
1921
        a.add(['foo', 'foo/bar', 'foo/baz'])
1902
1922
        a.commit('initial commit')
1912
1932
 
1913
1933
    def test_build_with_references(self):
1914
1934
        tree = self.make_branch_and_tree('source',
1915
 
            format='development-subtree')
 
1935
                                         format='development-subtree')
1916
1936
        subtree = self.make_branch_and_tree('source/subtree',
1917
 
            format='development-subtree')
 
1937
                                            format='development-subtree')
1918
1938
        tree.add_reference(subtree)
1919
1939
        tree.commit('a revision')
1920
1940
        tree.branch.create_checkout('target')
1930
1950
        source.commit('added file')
1931
1951
        build_tree(source.basis_tree(), target)
1932
1952
        self.assertEqual([DuplicateEntry('Moved existing file to',
1933
 
                          'file.moved', 'file', None, 'new-file')],
 
1953
                                         'file.moved', 'file', None, 'new-file')],
1934
1954
                         target.conflicts())
1935
1955
        target2 = self.make_branch_and_tree('target2')
1936
1956
        with open('target2/file', 'wb') as target_file, \
1950
1970
        os.symlink('bar', 'target/symlink')
1951
1971
        build_tree(source.basis_tree(), target)
1952
1972
        self.assertEqual([DuplicateEntry('Moved existing file to',
1953
 
            'symlink.moved', 'symlink', None, 'new-symlink')],
1954
 
            target.conflicts())
 
1973
                                         'symlink.moved', 'symlink', None, 'new-symlink')],
 
1974
                         target.conflicts())
1955
1975
        target = self.make_branch_and_tree('target2')
1956
1976
        os.symlink('foo', 'target2/symlink')
1957
1977
        build_tree(source.basis_tree(), target)
1985
2005
        self.assertPathExists('target3/dir1/file2')
1986
2006
        self.assertPathExists('target3/dir1.diverted/file')
1987
2007
        self.assertEqual([DuplicateEntry('Diverted to',
1988
 
            'dir1.diverted', 'dir1', 'new-dir1', None)],
1989
 
            target.conflicts())
 
2008
                                         'dir1.diverted', 'dir1', 'new-dir1', None)],
 
2009
                         target.conflicts())
1990
2010
 
1991
2011
        target = self.make_branch_and_tree('target4')
1992
2012
        self.build_tree(['target4/dir1/'])
1996
2016
        self.assertEqual('directory', file_kind('target4/dir1/file'))
1997
2017
        self.assertPathExists('target4/dir1/file.diverted')
1998
2018
        self.assertEqual([DuplicateEntry('Diverted to',
1999
 
            'dir1/file.diverted', 'dir1/file', 'new-file', None)],
2000
 
            target.conflicts())
 
2019
                                         'dir1/file.diverted', 'dir1/file', 'new-file', None)],
 
2020
                         target.conflicts())
2001
2021
 
2002
2022
    def test_mixed_conflict_handling(self):
2003
2023
        """Ensure that when building trees, conflict handling is done"""
2008
2028
        source.commit('added file')
2009
2029
        build_tree(source.basis_tree(), target)
2010
2030
        self.assertEqual([DuplicateEntry('Moved existing file to',
2011
 
            'name.moved', 'name', None, 'new-name')], target.conflicts())
 
2031
                                         'name.moved', 'name', None, 'new-name')], target.conflicts())
2012
2032
 
2013
2033
    def test_raises_in_populated(self):
2014
2034
        source = self.make_branch_and_tree('source')
2019
2039
        self.build_tree(['target/name'])
2020
2040
        target.add('name')
2021
2041
        self.assertRaises(errors.WorkingTreeAlreadyPopulated,
2022
 
            build_tree, source.basis_tree(), target)
 
2042
                          build_tree, source.basis_tree(), target)
2023
2043
 
2024
2044
    def test_build_tree_rename_count(self):
2025
2045
        source = self.make_branch_and_tree('source')
2054
2074
        self.build_tree_contents([('source/file2', b'C')])
2055
2075
        calls = []
2056
2076
        real_source_get_file = source.get_file
 
2077
 
2057
2078
        def get_file(path, file_id=None):
2058
2079
            calls.append(file_id)
2059
2080
            return real_source_get_file(path, file_id)
2106
2127
        os.symlink('file2', 'source/file1')
2107
2128
        calls = []
2108
2129
        real_source_get_file = source.get_file
 
2130
 
2109
2131
        def get_file(path, file_id=None):
2110
2132
            calls.append(file_id)
2111
2133
            return real_source_get_file(path, file_id)
2186
2208
        # below, but that looks a bit... hard to read even if it's exactly
2187
2209
        # the same thing.
2188
2210
        original_registry = filters._reset_registry()
 
2211
 
2189
2212
        def restore_registry():
2190
2213
            filters._reset_registry(original_registry)
2191
2214
        self.addCleanup(restore_registry)
 
2215
 
2192
2216
        def rot13(chunks, context=None):
2193
2217
            return [codecs.encode(chunk.decode('ascii'), 'rot13').encode('ascii')
2194
2218
                    for chunk in chunks]
2199
2223
        rules_filename = self.test_home_dir + '/.bazaar/rules'
2200
2224
        with open(rules_filename, 'wb') as f:
2201
2225
            f.write(b'[name %s]\nrot13=yes\n' % (pattern,))
 
2226
 
2202
2227
        def uninstall_rules():
2203
2228
            os.remove(rules_filename)
2204
2229
            rules.reset_rules()
2230
2255
 
2231
2256
    def test_case_insensitive_build_tree_inventory(self):
2232
2257
        if (features.CaseInsensitiveFilesystemFeature.available()
2233
 
            or features.CaseInsCasePresFilenameFeature.available()):
 
2258
                or features.CaseInsCasePresFilenameFeature.available()):
2234
2259
            raise tests.UnavailableFeature('Fully case sensitive filesystem')
2235
2260
        source = self.make_branch_and_tree('source')
2236
2261
        self.build_tree(['source/file', 'source/FILE'])
2274
2299
        entry2_state = entry2[1][0]
2275
2300
        # Now, make sure that we don't have to re-read the content. The
2276
2301
        # packed_stat should match exactly.
2277
 
        self.assertEqual(entry1_sha, target.get_file_sha1('file1', b'file1-id'))
 
2302
        self.assertEqual(
 
2303
            entry1_sha, target.get_file_sha1('file1', b'file1-id'))
2278
2304
        self.assertEqual(entry2_sha,
2279
2305
                         target.get_file_sha1('dir/file2', b'file2-id'))
2280
2306
        self.assertEqual(entry1_state, entry1[1][0])
2338
2364
        tt = TransformPreview(branch.basis_tree())
2339
2365
        self.addCleanup(tt.finalize)
2340
2366
        e = self.assertRaises(ValueError, tt.commit, branch,
2341
 
                          'my message', [b'rev1b-id'])
 
2367
                              'my message', [b'rev1b-id'])
2342
2368
        self.assertEqual('Cannot supply merge parents for first commit.',
2343
2369
                         str(e))
2344
2370
        self.assertEqual(_mod_revision.NULL_REVISION, branch.last_revision())
2392
2418
                           committer='me <me@example.com>',
2393
2419
                           revprops={u'foo': 'bar'}, revision_id=b'revid-1',
2394
2420
                           authors=['Author1 <author1@example.com>',
2395
 
                              'Author2 <author2@example.com>',
2396
 
                               ])
 
2421
                                    'Author2 <author2@example.com>',
 
2422
                                    ])
2397
2423
        self.assertEqual(b'revid-1', rev_id)
2398
2424
        revision = branch.repository.get_revision(rev_id)
2399
2425
        self.assertEqual(1, revision.timestamp)
2484
2510
 
2485
2511
        def rename(self, source, target):
2486
2512
            if (self.bad_source is not None and
2487
 
                source.endswith(self.bad_source)):
 
2513
                    source.endswith(self.bad_source)):
2488
2514
                raise Bogus
2489
2515
            elif (self.bad_target is not None and
2490
 
                target.endswith(self.bad_target)):
 
2516
                  target.endswith(self.bad_target)):
2491
2517
                raise Bogus
2492
2518
            else:
2493
2519
                _FileMover.rename(self, source, target)
2548
2574
        new_globals = dict(func.__globals__)
2549
2575
        new_globals.update(globals)
2550
2576
        new_func = types.FunctionType(func.__code__, new_globals,
2551
 
            func.__name__, func.__defaults__)
 
2577
                                      func.__name__, func.__defaults__)
2552
2578
        if PY3:
2553
2579
            setattr(instance, method_name,
2554
 
                types.MethodType(new_func, instance))
 
2580
                    types.MethodType(new_func, instance))
2555
2581
        else:
2556
2582
            setattr(instance, method_name,
2557
 
                types.MethodType(new_func, instance, instance.__class__))
 
2583
                    types.MethodType(new_func, instance, instance.__class__))
2558
2584
        self.addCleanup(delattr, instance, method_name)
2559
2585
 
2560
2586
    @staticmethod
2587
2613
    def test_root_create_file_open_raises_before_creation(self):
2588
2614
        tt, trans_id = self.create_transform_and_root_trans_id()
2589
2615
        self._override_globals_in_method(tt, "create_file",
2590
 
            {"open": self._fake_open_raises_before})
2591
 
        self.assertRaises(RuntimeError, tt.create_file, [b"contents"], trans_id)
 
2616
                                         {"open": self._fake_open_raises_before})
 
2617
        self.assertRaises(RuntimeError, tt.create_file,
 
2618
                          [b"contents"], trans_id)
2592
2619
        path = tt._limbo_name(trans_id)
2593
2620
        self.assertPathDoesNotExist(path)
2594
2621
        tt.finalize()
2597
2624
    def test_root_create_file_open_raises_after_creation(self):
2598
2625
        tt, trans_id = self.create_transform_and_root_trans_id()
2599
2626
        self._override_globals_in_method(tt, "create_file",
2600
 
            {"open": self._fake_open_raises_after})
2601
 
        self.assertRaises(RuntimeError, tt.create_file, [b"contents"], trans_id)
 
2627
                                         {"open": self._fake_open_raises_after})
 
2628
        self.assertRaises(RuntimeError, tt.create_file,
 
2629
                          [b"contents"], trans_id)
2602
2630
        path = tt._limbo_name(trans_id)
2603
2631
        self.assertPathExists(path)
2604
2632
        tt.finalize()
2608
2636
    def test_subdir_create_file_open_raises_before_creation(self):
2609
2637
        tt, trans_id = self.create_transform_and_subdir_trans_id()
2610
2638
        self._override_globals_in_method(tt, "create_file",
2611
 
            {"open": self._fake_open_raises_before})
2612
 
        self.assertRaises(RuntimeError, tt.create_file, [b"contents"], trans_id)
 
2639
                                         {"open": self._fake_open_raises_before})
 
2640
        self.assertRaises(RuntimeError, tt.create_file,
 
2641
                          [b"contents"], trans_id)
2613
2642
        path = tt._limbo_name(trans_id)
2614
2643
        self.assertPathDoesNotExist(path)
2615
2644
        tt.finalize()
2618
2647
    def test_subdir_create_file_open_raises_after_creation(self):
2619
2648
        tt, trans_id = self.create_transform_and_subdir_trans_id()
2620
2649
        self._override_globals_in_method(tt, "create_file",
2621
 
            {"open": self._fake_open_raises_after})
2622
 
        self.assertRaises(RuntimeError, tt.create_file, [b"contents"], trans_id)
 
2650
                                         {"open": self._fake_open_raises_after})
 
2651
        self.assertRaises(RuntimeError, tt.create_file,
 
2652
                          [b"contents"], trans_id)
2623
2653
        path = tt._limbo_name(trans_id)
2624
2654
        self.assertPathExists(path)
2625
2655
        tt.finalize()
2637
2667
                os.rename(old, new)
2638
2668
                raise RuntimeError
2639
2669
        self._override_globals_in_method(tt, "_rename_in_limbo",
2640
 
            {"os": FakeOSModule()})
 
2670
                                         {"os": FakeOSModule()})
2641
2671
        self.assertRaises(
2642
2672
            RuntimeError, tt.adjust_path, "child1", parent2, child1)
2643
2673
        path = osutils.pathjoin(tt._limbo_name(parent2), "child1")
2656
2686
            def rename(self, old, new):
2657
2687
                raise RuntimeError
2658
2688
        self._override_globals_in_method(tt, "_rename_in_limbo",
2659
 
            {"os": FakeOSModule()})
 
2689
                                         {"os": FakeOSModule()})
2660
2690
        self.assertRaises(
2661
2691
            RuntimeError, tt.adjust_path, "child1", parent2, child1)
2662
2692
        path = osutils.pathjoin(tt._limbo_name(parent1), "child1")
2670
2700
 
2671
2701
    def make_tt_with_versioned_dir(self):
2672
2702
        wt = self.make_branch_and_tree('.')
2673
 
        self.build_tree(['dir/',])
 
2703
        self.build_tree(['dir/', ])
2674
2704
        wt.add(['dir'], [b'dir-id'])
2675
2705
        wt.commit('Create dir')
2676
2706
        tt = TreeTransform(wt)
2680
2710
    def test_resolve_create_parent_for_versioned_file(self):
2681
2711
        wt, tt = self.make_tt_with_versioned_dir()
2682
2712
        dir_tid = tt.trans_id_tree_path('dir')
2683
 
        file_tid = tt.new_file('file', dir_tid, [b'Contents'], file_id=b'file-id')
 
2713
        file_tid = tt.new_file(
 
2714
            'file', dir_tid, [b'Contents'], file_id=b'file-id')
2684
2715
        tt.delete_contents(dir_tid)
2685
2716
        tt.unversion_file(dir_tid)
2686
2717
        conflicts = resolve_conflicts(tt)
2702
2733
 
2703
2734
 
2704
2735
A_ENTRY = (b'a-id', ('a', 'a'), True, (True, True),
2705
 
                  (b'TREE_ROOT', b'TREE_ROOT'), ('a', 'a'), ('file', 'file'),
2706
 
                  (False, False))
 
2736
           (b'TREE_ROOT', b'TREE_ROOT'), ('a', 'a'), ('file', 'file'),
 
2737
           (False, False))
2707
2738
ROOT_ENTRY = (b'TREE_ROOT', ('', ''), False, (True, True), (None, None),
2708
2739
              ('', ''), ('directory', 'directory'), (False, False))
2709
2740
 
2782
2813
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2783
2814
        root = revision_tree.get_root_id()
2784
2815
        self.assertEqual([(b'a-id', ('a', 'a'), True, (True, True),
2785
 
                          (root, root), ('a', 'a'), ('file', 'file'),
2786
 
                          (False, False))],
2787
 
                          list(preview_tree.iter_changes(revision_tree)))
 
2816
                           (root, root), ('a', 'a'), ('file', 'file'),
 
2817
                           (False, False))],
 
2818
                         list(preview_tree.iter_changes(revision_tree)))
2788
2819
 
2789
2820
    def test_include_unchanged_succeeds(self):
2790
2821
        revision_tree, preview_tree = self.get_tree_and_preview_tree()
2912
2943
        preview = TransformPreview(tree)
2913
2944
        self.addCleanup(preview.finalize)
2914
2945
        preview.new_file('new', preview.trans_id_file_id(b'unchanged-id'),
2915
 
            [b'contents'], b'new-id')
 
2946
                         [b'contents'], b'new-id')
2916
2947
        preview_tree = preview.get_preview_tree()
2917
2948
        self.assertEqual(b'new-id', preview_tree.path2id('unchanged/new'))
2918
2949
 
3017
3048
 
3018
3049
    def test_file_content_summary_executable(self):
3019
3050
        preview = self.get_empty_preview()
3020
 
        path_id = preview.new_file('path', preview.root, [b'contents'], b'path-id')
 
3051
        path_id = preview.new_file('path', preview.root, [
 
3052
                                   b'contents'], b'path-id')
3021
3053
        preview.set_executability(True, path_id)
3022
3054
        summary = preview.get_preview_tree().path_content_summary('path')
3023
3055
        self.assertEqual(4, len(summary))
3084
3116
            (b'me:', b'b\n'),
3085
3117
            (b'me:', b'c\n'),
3086
3118
        ]
3087
 
        annotation = preview_tree.annotate_iter('file', default_revision=b'me:')
 
3119
        annotation = preview_tree.annotate_iter(
 
3120
            'file', default_revision=b'me:')
3088
3121
        self.assertEqual(expected, annotation)
3089
3122
 
3090
3123
    def test_annotate_missing(self):
3095
3128
            (b'me:', b'a\n'),
3096
3129
            (b'me:', b'b\n'),
3097
3130
            (b'me:', b'c\n'),
3098
 
         ]
3099
 
        annotation = preview_tree.annotate_iter('file', default_revision=b'me:')
 
3131
            ]
 
3132
        annotation = preview_tree.annotate_iter(
 
3133
            'file', default_revision=b'me:')
3100
3134
        self.assertEqual(expected, annotation)
3101
3135
 
3102
3136
    def test_annotate_rename(self):
3112
3146
        expected = [
3113
3147
            (b'one', b'a\n'),
3114
3148
        ]
3115
 
        annotation = preview_tree.annotate_iter('file', default_revision=b'me:')
 
3149
        annotation = preview_tree.annotate_iter(
 
3150
            'file', default_revision=b'me:')
3116
3151
        self.assertEqual(expected, annotation)
3117
3152
 
3118
3153
    def test_annotate_deleted(self):
3126
3161
        file_trans_id = preview.trans_id_file_id(b'file-id')
3127
3162
        preview.delete_contents(file_trans_id)
3128
3163
        preview_tree = preview.get_preview_tree()
3129
 
        annotation = preview_tree.annotate_iter('file', default_revision=b'me:')
 
3164
        annotation = preview_tree.annotate_iter(
 
3165
            'file', default_revision=b'me:')
3130
3166
        self.assertIs(None, annotation)
3131
3167
 
3132
3168
    def test_stored_kind(self):
3203
3239
        file_trans_id = preview.new_file('a', preview.root, [b'contents'],
3204
3240
                                         b'a-id')
3205
3241
        expected = [(('', b'tree-root'),
3206
 
                    [('a', 'a', 'file', None, b'a-id', 'file')])]
 
3242
                     [('a', 'a', 'file', None, b'a-id', 'file')])]
3207
3243
        self.assertEqual(expected, list(preview_tree.walkdirs()))
3208
3244
 
3209
3245
    def test_extras(self):
3248
3284
        self.addCleanup(tt.finalize)
3249
3285
        final_tree = tt.get_preview_tree()
3250
3286
        self.assertEqual(
3251
 
                b'a\nb\nc\n',
3252
 
                final_tree.get_file_text(final_tree.id2path(b'file-id')))
 
3287
            b'a\nb\nc\n',
 
3288
            final_tree.get_file_text(final_tree.id2path(b'file-id')))
3253
3289
 
3254
3290
    def test_merge_preview_into_workingtree(self):
3255
3291
        tree = self.make_branch_and_tree('tree')
3305
3341
        self.addCleanup(preview.finalize)
3306
3342
        preview.new_file('foo', preview.root, [b'bar'], b'baz-id')
3307
3343
        preview_tree = preview.get_preview_tree()
3308
 
        self.assertEqual(False, preview_tree.is_executable('tree/foo', b'baz-id'))
 
3344
        self.assertEqual(
 
3345
            False, preview_tree.is_executable('tree/foo', b'baz-id'))
3309
3346
        self.assertEqual(False, preview_tree.is_executable('tree/foo'))
3310
3347
 
3311
3348
    def test_commit_preview_tree(self):
3485
3522
        attribs = self.default_attribs()
3486
3523
        attribs[b'_id_number'] = 2
3487
3524
        attribs[b'_non_present_ids'] = {
3488
 
            b'boo': b'new-1',}
 
3525
            b'boo': b'new-1', }
3489
3526
        return self.make_records(attribs, [])
3490
3527
 
3491
3528
    def test_serialize_missing(self):
3511
3548
        attribs[b'_id_number'] = 2
3512
3549
        attribs[b'_tree_path_ids'] = {
3513
3550
            b'file': b'new-1',
3514
 
            b'': b'new-0',}
 
3551
            b'': b'new-0', }
3515
3552
        attribs[b'_removed_contents'] = [b'new-1']
3516
3553
        contents = [(b'new-1', b'file',
3517
3554
                     b'i 1\nz\n\nc 0 1 1 1\ni 1\nx\n\nc 0 3 3 1\n')]
3541
3578
        attribs[b'_id_number'] = 2
3542
3579
        attribs[b'_tree_path_ids'] = {
3543
3580
            b'foo': b'new-1',
3544
 
            b'': b'new-0',}
 
3581
            b'': b'new-0', }
3545
3582
        attribs[b'_removed_contents'] = [b'new-1']
3546
3583
        contents = [(b'new-1', b'file',
3547
3584
                     b'i 4\na\nb\nc\nd\n\n')]
3572
3609
        attribs[b'_id_number'] = 2
3573
3610
        attribs[b'_tree_path_ids'] = {
3574
3611
            b'foo': b'new-1',
3575
 
            b'': b'new-0',}
 
3612
            b'': b'new-0', }
3576
3613
        contents = [(b'new-1', b'file',
3577
3614
                     b'i 4\na\nb\nc\nd\n\n')]
3578
3615
        return self.make_records(attribs, contents)
3597
3634
        tt = self.get_preview(tree)
3598
3635
        trans_id = tt.trans_id_tree_path('file')
3599
3636
        self.assertEqual(([b'aa\n', b'bb\n', b'cc\n', b'dd\n'],),
3600
 
            tt._get_parents_lines(trans_id))
 
3637
                         tt._get_parents_lines(trans_id))
3601
3638
 
3602
3639
    def test_get_parents_texts(self):
3603
3640
        LINES_ONE = b'aa\nbb\ncc\ndd\n'
3608
3645
        tt = self.get_preview(tree)
3609
3646
        trans_id = tt.trans_id_tree_path('file')
3610
3647
        self.assertEqual((LINES_ONE,),
3611
 
            tt._get_parents_texts(trans_id))
 
3648
                         tt._get_parents_texts(trans_id))
3612
3649
 
3613
3650
 
3614
3651
class TestOrphan(tests.TestCaseWithTransport):
3621
3658
 
3622
3659
    def _set_orphan_policy(self, wt, policy):
3623
3660
        wt.branch.get_config_stack().set('transform.orphan_policy',
3624
 
                                               policy)
 
3661
                                         policy)
3625
3662
 
3626
3663
    def _prepare_orphan(self, wt):
3627
3664
        self.build_tree(['dir/', 'dir/file', 'dir/foo'])
3648
3685
        self._set_orphan_policy(wt, 'move')
3649
3686
        tt, orphan_tid = self._prepare_orphan(wt)
3650
3687
        warnings = []
 
3688
 
3651
3689
        def warning(*args):
3652
3690
            warnings.append(args[0] % args[1:])
3653
3691
        self.overrideAttr(trace, 'warning', warning)
3654
3692
        remaining_conflicts = resolve_conflicts(tt)
3655
3693
        self.assertEqual(['dir/foo has been orphaned in brz-orphans'],
3656
 
                          warnings)
 
3694
                         warnings)
3657
3695
        # Yeah for resolved conflicts !
3658
3696
        self.assertLength(0, remaining_conflicts)
3659
3697
        # We have a new orphan
3660
3698
        self.assertEqual('foo.~1~', tt.final_name(orphan_tid))
3661
3699
        self.assertEqual('brz-orphans',
3662
 
                          tt.final_name(tt.final_parent(orphan_tid)))
 
3700
                         tt.final_name(tt.final_parent(orphan_tid)))
3663
3701
 
3664
3702
    def test_never_orphan(self):
3665
3703
        wt = self.make_branch_and_tree('.')
3690
3728
        self._set_orphan_policy(wt, 'donttouchmypreciouuus')
3691
3729
        tt, orphan_tid = self._prepare_orphan(wt)
3692
3730
        warnings = []
 
3731
 
3693
3732
        def warning(*args):
3694
3733
            warnings.append(args[0] % args[1:])
3695
3734
        self.overrideAttr(trace, 'warning', warning)
3716
3755
 
3717
3756
    def test_pre_commit_hooks(self):
3718
3757
        calls = []
 
3758
 
3719
3759
        def record_pre_transform(tree, tt):
3720
3760
            calls.append((tree, tt))
3721
3761
        MutableTree.hooks.install_named_hook('pre_transform',
3722
 
            record_pre_transform, "Pre transform")
 
3762
                                             record_pre_transform, "Pre transform")
3723
3763
        transform, root = self.get_transform()
3724
3764
        old_root_id = transform.tree_file_id(root)
3725
3765
        transform.apply()
3728
3768
 
3729
3769
    def test_post_commit_hooks(self):
3730
3770
        calls = []
 
3771
 
3731
3772
        def record_post_transform(tree, tt):
3732
3773
            calls.append((tree, tt))
3733
3774
        MutableTree.hooks.install_named_hook('post_transform',
3734
 
            record_post_transform, "Post transform")
 
3775
                                             record_post_transform, "Post transform")
3735
3776
        transform, root = self.get_transform()
3736
3777
        old_root_id = transform.tree_file_id(root)
3737
3778
        transform.apply()