← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to tests/test_baz_import.py

  • Committer: Aaron Bentley
  • Date: 2007-05-18 09:20:47 UTC
  • Revision ID: aaron.bentley@utoronto.ca-20070518092047-c25wfogkpw1c8yj1
Tags: release-0.17.0
Update version number to 0.17.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_baz_import.py
16
16
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
18
from bzrlib.tests import TestCaseInTempDir, TestCase
 
19
from bzrlib import repository
19
20
from bzrlib.osutils import has_symlinks
20
21
try:
21
22
    import pybaz
22
23
except ImportError:
23
24
    pybaz = None
24
25
import os
25
 
try:
26
 
    from bzrtools.baz_import import (import_version, revision_id,
27
 
                                     cmd_baz_import, make_archive, map_file_id)
28
 
except ImportError:
29
 
    from bzrlib.plugins.bzrtools.baz_import import (import_version, 
30
 
                                                    revision_id,
31
 
                                                    cmd_baz_import,
32
 
                                                    make_archive,
33
 
                                                    map_file_id)
34
 
from bzrlib.errors import NoSuchRevision
 
26
from bzrlib.plugins.bzrtools import cmd_baz_import 
 
27
from bzrlib.plugins.bzrtools.baz_import import (import_version, 
 
28
                                                revision_id,
 
29
                                                make_archive,
 
30
                                                map_file_id)
35
31
import shutil
36
32
from StringIO import StringIO
37
33
import tempfile
38
34
from testresources import (TestResource, TestLoader, OptimisingTestSuite,
39
35
                               ResourcedTestCase)
40
36
    
41
 
try:
42
 
    from bzrtools.fai import namespace_previous
43
 
except ImportError:
44
 
    from bzrlib.plugins.bzrtools.fai import namespace_previous
 
37
import bzrlib
 
38
from bzrlib.errors import NoSuchRevision
 
39
from bzrlib.plugins.bzrtools.fai import namespace_previous
45
40
from bzrlib.branch import Branch
46
41
 
47
42
def test_suite():
69
64
        pybaz.set_my_id("Test User<test@example.org>")
70
65
 
71
66
        self.make_empty_import()
 
67
        self.make_utf8_log()
72
68
 
73
69
        self._empty_tag = 'demo@DONOTUSE/c--empty-tag--0'
74
 
        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0')
 
70
        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0', None)
75
71
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
76
72
            pybaz.Version(self._empty_tag))
77
73
 
78
74
        self._empty_merged_tag = 'demo@DONOTUSE/c--empty-merged-tag--0'
79
75
        self._empty_merged_tag_bzr_base = revision_id(self._empty_merged_tag 
80
 
                                                 + '--base-0')
 
76
                                                 + '--base-0', None)
81
77
        self._empty_merged_tag_bzr = revision_id(self._empty_merged_tag 
82
 
                                                 + '--patch-1')
 
78
                                                 + '--patch-1', None)
83
79
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
84
80
            pybaz.Version(self._empty_merged_tag))
85
81
        tree = pybaz.Revision(self._empty_merged_tag + '--base-0').get(
94
90
        # tree, two commits, includes merge of other branch
95
91
        self._empty_merged_tag_2 = 'demo@DONOTUSE/c--empty-tag-2--0'
96
92
        self._empty_merged_tag_2_bzr_base = revision_id(
97
 
            self._empty_merged_tag_2 + '--base-0')
 
93
            self._empty_merged_tag_2 + '--base-0', None)
98
94
        self._empty_merged_tag_2_bzr = revision_id(
99
 
            self._empty_merged_tag_2 + '--patch-1')
 
95
            self._empty_merged_tag_2 + '--patch-1', None)
100
96
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
101
97
            pybaz.Version(self._empty_merged_tag_2))
102
98
        tree = pybaz.Revision(self._empty_merged_tag_2 + '--base-0').get (
109
105
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
110
106
 
111
107
        self._bad_id_tag = 'demo@DONOTUSE/c--bad-id--0'
112
 
        self._bad_id_tag_bzr_base = revision_id(self._bad_id_tag + '--base-0')
113
 
        self._bad_id_tag_bzr = revision_id(self._bad_id_tag + '--patch-1')
 
108
        self._bad_id_tag_bzr_base = revision_id(self._bad_id_tag + '--base-0',
 
109
                                                None)
 
110
        self._bad_id_tag_bzr = revision_id(self._bad_id_tag + '--patch-1',
 
111
                                           None)
114
112
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
115
113
            pybaz.Version(self._bad_id_tag))
116
114
        tree = pybaz.Revision(self._bad_id_tag + '--base-0').get(
130
128
    def make_import_symlink(self):
131
129
        self._import_symlink = 'demo@DONOTUSE/c--import-symlink--0'
132
130
        self._import_symlink_bzr = revision_id(
133
 
            self._import_symlink + '--base-0')
 
131
            self._import_symlink + '--base-0', None)
134
132
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
135
133
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
136
134
                               self._import_symlink)
137
 
        os.symlink('missing-file-name',
138
 
                   os.path.join(self._tmpdir, 'tree', 'alink'))
 
135
        link_path = os.path.join(self._tmpdir, 'tree', 'alink')
 
136
        os.symlink('missing-file-name', link_path)
139
137
        tree.add_tag('alink')
140
138
        id_file = open(os.path.join(tree, '.arch-ids', 'alink.id'), 'w')
141
139
        id_file.write('symlink_tag\n')
143
141
        msg = tree.log_message()
144
142
        msg["summary"] = "Import with a symlink"
145
143
        tree.import_(msg)
 
144
        os.unlink(link_path)
 
145
        f = file(link_path, 'w')
 
146
        f.write('Not a symlink no more!')
 
147
        f.close()
 
148
        msg = tree.log_message()
 
149
        msg["summary"] = "Turn a symlink into a file"
 
150
        tree.commit(msg)
146
151
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
147
152
 
148
153
    def make_empty_import(self):
155
160
        tree.import_(msg)
156
161
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
157
162
 
 
163
    def make_utf8_log(self):
 
164
        self._utf8 = 'demo@DONOTUSE/c--utf8--0'
 
165
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
 
166
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
167
                               self._utf8)
 
168
        msg = tree.log_message()
 
169
        msg["summary"] = u"I am importing now\u1234".encode('utf-8')
 
170
        tree.import_(msg)
 
171
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
 
172
 
158
173
    def make_missing_ancestor(self):
159
174
        self._archivegoneroot = os.path.join(self._tmpdir, 'archivegone')
160
175
        self._archive = make_archive('demo-gone@DONOTUSE',
161
176
                                     str(self._archivegoneroot))
162
177
        self._missing_import = 'demo-gone@DONOTUSE/c--import--0'
163
178
        self._missing_import_bzr = revision_id(self._missing_import 
164
 
                                                 + '--base-0')
 
179
                                                 + '--base-0', None)
165
180
        self._missing_ancestor = 'demo@DONOTUSE/c--gone--0'
166
181
        self._missing_ancestor_bzr = revision_id(self._missing_ancestor 
167
 
                                                 + '--base-0')
 
182
                                                 + '--base-0', None)
168
183
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
169
184
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
170
185
                               self._missing_import)
177
192
            pybaz.Version(self._missing_ancestor))
178
193
 
179
194
        # make an import for testing history-reuse logic.
180
 
        def collect(text):
181
 
            pass
182
195
        # note the use of a namespace layout here.
183
196
        self._missing_import_imported = os.path.join(self._tmpdir, 
184
197
                                                     'archivegone-bzr')
186
199
        os.mkdir(os.path.join(self._tmpdir, 'archivegone-bzr', 'c'))
187
200
        import_version(os.path.join(self._tmpdir, 'archivegone-bzr', 
188
201
                                    'c', 'import'),
189
 
                       pybaz.Version(self._missing_import),
190
 
                       collect)
 
202
                       pybaz.Version(self._missing_import), None)
191
203
        # and make it inaccessible
192
204
        pybaz.Archive('demo-gone@DONOTUSE').unregister()
193
205
 
194
206
    def make_inbranch_continuation(self):
195
207
        self._inbranch_tag = 'demo@DONOTUSE/c--inbranch-tag--0'
196
208
        self._inbranch_tag_base = self._inbranch_tag + '--base-0'
197
 
        self._inbranch_tag_base_bzr = revision_id(self._inbranch_tag_base)
 
209
        self._inbranch_tag_base_bzr = revision_id(self._inbranch_tag_base, 
 
210
                                                  None)
198
211
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
199
212
            pybaz.Version(self._inbranch_tag))
200
213
        self._inbranch_tag_head = self._inbranch_tag + '--patch-1'
201
 
        self._inbranch_tag_head_bzr = revision_id(self._inbranch_tag_head)
 
214
        self._inbranch_tag_head_bzr = revision_id(self._inbranch_tag_head,
 
215
                                                  None)
202
216
        pybaz.Revision(self._inbranch_tag_base).make_continuation(
203
217
            pybaz.Version(self._inbranch_tag))
204
218
 
219
233
        TestCaseInTempDir.setUp(self)
220
234
        ResourcedTestCase.setUpResources(self)
221
235
        os.environ['HOME'] = self._baz._homedir
222
 
        self.output = StringIO()
223
236
 
224
237
    def tearDown(self):
225
238
        ResourcedTestCase.tearDownResources(self)
226
239
        TestCaseInTempDir.tearDown(self)
227
 
 
228
 
    def collect(self, text):
229
 
        self.output.write(text)
230
 
        self.output.write("\n")
231
 
 
 
240
 
 
241
    def test_import_utf8(self):
 
242
        import_version('output', pybaz.Version(self._baz._utf8), None)
 
243
        branch = Branch.open('output')
 
244
        plain_revid = 'Arch-1:demo@DONOTUSE%c--utf8--0--base-0'
 
245
        self.assertEqual([plain_revid], branch.revision_history())
 
246
        self.assertEqual(u'I am importing now\ufffd\ufffd\ufffd',
 
247
                         branch.repository.get_revision(plain_revid).message)
 
248
        import_version('output2', pybaz.Version(self._baz._utf8), 'utf-8')
 
249
        branch2 = Branch.open('output2')
 
250
        utf8_revid = 'Arch-1-utf-8:demo@DONOTUSE%c--utf8--0--base-0'
 
251
        self.assertEqual([utf8_revid], branch2.revision_history())
 
252
        self.assertEqual(u'I am importing now\u1234',
 
253
                         branch2.repository.get_revision(utf8_revid).message)
 
254
 
232
255
    def test_import_empty(self):
233
 
        import_version('output', pybaz.Version(self._baz._import), 
234
 
                       self.collect)
 
256
        import_version('output', pybaz.Version(self._baz._import), None)
235
257
        # expected results:
236
258
        # one commit, no files, revision identifier of 
237
259
        # 'demo@DONOTUSE_c--import--0--base-0'
242
264
        rev = repo.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
243
265
        # and again.
244
266
        import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'),
245
 
                       self.collect)
 
267
                       None)
246
268
        branch2 = Branch.open('output2')
247
269
        repo2 = branch2.repository
248
270
        self.assertEqual(branch.revision_history(), branch2.revision_history())
257
279
                         "Arch-1:demo@DONOTUSE%c--import--0--base-0")
258
280
 
259
281
    def test_empty_tagged(self):
260
 
        import_version('output', pybaz.Version(self._baz._empty_tag),
261
 
                       self.collect)
 
282
        import_version('output', pybaz.Version(self._baz._empty_tag), None)
262
283
        # expected results:
263
284
        # two commits, no files, revision identifiers of 
264
285
        # 'demo@DONOTUSE_c--import--0--base-0' and
269
290
                          self._baz._empty_tag_bzr])
270
291
        rev = branch.repository.get_revision(self._baz._empty_tag_bzr)
271
292
        # and again.
272
 
        import_version('output2', pybaz.Version(self._baz._empty_tag),
273
 
                       self.collect)
 
293
        import_version('output2', pybaz.Version(self._baz._empty_tag), None)
274
294
        branch2 = Branch.open('output2')
275
295
        self.assertEqual(branch.revision_history(), branch2.revision_history())
276
296
        rev2 = branch2.repository.get_revision(self._baz._empty_tag_bzr)
284
304
        self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)
285
305
 
286
306
    def test_empty_merged_tagged(self):
287
 
        import_version('output', pybaz.Version(self._baz._empty_merged_tag),
288
 
                       self.collect)
 
307
        import_version('output', pybaz.Version(self._baz._empty_merged_tag), 
 
308
                       None)
289
309
        # expected results:
290
310
        # two commits, no files, revision identifiers of 
291
311
        # 'demo@DONOTUSE_c--import--0--base-0' and
300
320
                          self._baz._empty_merged_tag_bzr_base,
301
321
                          self._baz._empty_merged_tag_bzr])
302
322
        # and again.
303
 
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag),
304
 
                       self.collect)
 
323
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag), 
 
324
                       None)
305
325
        branch2 = Branch.open('output2')
306
326
        repo2 = branch2.repository
307
327
        # and import what we should be merged up against for checking with.
308
 
        import_version('output3', pybaz.Version(self._baz._empty_tag),
309
 
                       self.collect)
 
328
        import_version('output3', pybaz.Version(self._baz._empty_tag), None)
310
329
        branch3 = Branch.open('output3')
311
330
        
312
331
        self.assertEqual(branch.revision_history(), branch2.revision_history())
343
362
        # self.assertEqual(branch.missing_revisions(branch3), [])
344
363
        
345
364
    def test_merge_branch_with_merges(self):
346
 
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2),
347
 
                       self.collect)
 
365
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2), 
 
366
                       None)
348
367
        # expected results:
349
368
        # two commits, no files, revision identifiers of 
350
369
        # 'demo@DONOTUSE_c--import--0--base-0' and
360
379
                          self._baz._empty_merged_tag_2_bzr])
361
380
        # and again.
362
381
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2),
363
 
                       self.collect)
 
382
                       None)
364
383
        branch2 = Branch.open('output2')
365
384
        repo2 = branch2.repository
366
385
        # and import what we should be merged up against for checking with.
367
386
        import_version('output3', pybaz.Version(self._baz._empty_merged_tag),
368
 
                       self.collect)
 
387
                       None)
369
388
        branch3 = Branch.open('output3')
370
389
        
371
390
        self.assertEqual(branch.revision_history(), branch2.revision_history())
402
421
        # self.assertEqual(branch.missing_revisions(branch3), [])
403
422
        
404
423
    def test_import_symlink(self):
405
 
        import_version('output', pybaz.Version(self._baz._import_symlink),
406
 
                       self.collect)
 
424
        import_version('output', pybaz.Version(self._baz._import_symlink), 
 
425
                       None, max_count=1)
407
426
        # expected results:
408
 
        # one commit, no files, revision identifier of 
 
427
        # two commits, no files, revision identifier of 
409
428
        # 'demo@DONOTUSE_c--import--0--base-0'
410
429
        branch = Branch.open('output')
411
430
        self.assertEqual(branch.revision_history(),
413
432
        rev = branch.repository.get_revision(self._baz._import_symlink_bzr)
414
433
        # and again.
415
434
        import_version('output2', pybaz.Version(self._baz._import_symlink),
416
 
                       self.collect)
 
435
                       None, max_count=1)
417
436
        branch2 = Branch.open('output2')
418
437
        self.assertEqual(branch.revision_history(), branch2.revision_history())
419
438
        rev2 = branch2.repository.get_revision(self._baz._import_symlink_bzr)
432
451
        self.assertEqual(entry.kind, 'symlink')
433
452
        self.assertEqual(entry.symlink_target, 'missing-file-name')
434
453
 
 
454
        # Test kind change for import
 
455
        import_version('output3', pybaz.Version(self._baz._import_symlink),
 
456
                       None)
 
457
 
435
458
    def test_missing_ancestor(self):
436
459
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
437
 
                       self.collect)
 
460
                       None)
438
461
        # expected results:
439
462
        # one commits, no files, revision identifiers of 
440
463
        # 'demo@DONOTUSE_c--gone--0--base-0' and
444
467
                         [self._baz._missing_ancestor_bzr])
445
468
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
446
469
        # and again.
447
 
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
448
 
                       self.collect)
 
470
        import_version('output2', pybaz.Version(self._baz._missing_ancestor), 
 
471
                       None)
449
472
        branch2 = Branch.open('output2')
450
473
        self.assertEqual(branch.revision_history(), branch2.revision_history())
451
474
        rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)
466
489
 
467
490
    def test_missing_ancestor_reusing_history(self):
468
491
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
469
 
                       self.collect,
 
492
                       None,
470
493
                       reuse_history_from=[self._baz._missing_import_imported])
471
494
        # expected results:
472
495
        # one commits, no files, revision identifiers of 
479
502
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
480
503
        # and again.
481
504
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
482
 
                       self.collect,
 
505
                       None,
483
506
                       reuse_history_from=[self._baz._missing_import_imported])
484
507
        branch2 = Branch.open('output2')
485
508
        self.assertEqual(branch.revision_history(), branch2.revision_history())
499
522
        self.assertEqual(1, len(rev.parent_ids))
500
523
 
501
524
    def test_bad_file_id(self):
502
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
503
 
                       self.collect)
 
525
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
504
526
        # expected results:
505
527
        # three commits, one files, revision identifiers of 
506
528
        # 'demo@DONOTUSE_c--import--0--base-0' ,
517
539
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
518
540
 
519
541
    def test_appending_revisions_already_present(self):
520
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
521
 
                       self.collect, max_count=2)
 
542
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None,
 
543
                       max_count=2)
522
544
        # expected results:
523
545
        # three commits, one files, revision identifiers of 
524
546
        # 'demo@DONOTUSE_c--import--0--base-0' ,
535
557
        self.assertEqual(branch.revision_history(),
536
558
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
537
559
        del branch
538
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
539
 
                       self.collect)
 
560
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
540
561
        branch = Branch.open('output')
541
562
        self.assertEqual(branch.revision_history(),
542
563
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
548
569
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
549
570
 
550
571
    def test_appending_revisions_all_already_present(self):
551
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
552
 
                       self.collect)
 
572
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
553
573
        # expected results:
554
574
        # three commits, one files, revision identifiers of 
555
575
        # 'demo@DONOTUSE_c--import--0--base-0' ,
567
587
        self.assertEqual(branch.revision_history(),
568
588
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
569
589
        del branch
570
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
571
 
                       self.collect)
 
590
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
572
591
        branch = Branch.open('output')
573
592
        self.assertEqual(branch.revision_history(),
574
593
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
580
599
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
581
600
 
582
601
    def test_inbranch_conversion(self):
583
 
        import_version('output', pybaz.Version(self._baz._inbranch_tag),
584
 
                       self.collect)
 
602
        import_version('output', pybaz.Version(self._baz._inbranch_tag), None)
585
603
        # expected results:
586
604
        # three commits, no files, revision identifiers of 
587
605
        # 'demo@DONOTUSE_c--import--0--base-0' and
594
612
                          self._baz._inbranch_tag_base_bzr,
595
613
                          self._baz._inbranch_tag_head_bzr])
596
614
        # and again.
597
 
        import_version('output2', pybaz.Version(self._baz._inbranch_tag),
598
 
                       self.collect)
 
615
        import_version('output2', pybaz.Version(self._baz._inbranch_tag), None)
599
616
        branch2 = Branch.open('output2')
600
617
        
601
618
        self.assertEqual(branch.revision_history(), branch2.revision_history())
621
638
        self.assertEqual(rev.parent_ids,
622
639
                         [self._baz._inbranch_tag_base_bzr])
623
640
 
 
641
    def test_no_commits_same_as_missing(self):
 
642
        path = 'output'
 
643
        os.mkdir(path)
 
644
        branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(path)
 
645
        import_version(path, pybaz.Version(self._baz._import), None)
 
646
        # expected results:
 
647
        # one commit, revision identifier of 
 
648
        # 'demo@DONOTUSE_c--import--0--base-0'
 
649
        self.assertEqual(branch.revision_history(),
 
650
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
 
651
 
624
652
 
625
653
class TestNamespacePrevious(TestCase):
626
654
 
651
679
        self.assertEqual(namespace_previous(self.version['versionfix-3000']),
652
680
                         self.version['versionfix-2999'])
653
681
 
 
682
 
654
683
class TestNamespaceMapping(TestCase):
655
684
 
656
685
    def test_namespace_mapping_branch(self):
705
734
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
706
735
 
707
736
    def test_cmd_exists(self):
708
 
        from bzrlib.plugins.bzrtools.baz_import import cmd_baz_import
 
737
        from bzrlib.plugins.bzrtools import cmd_baz_import
709
738
 
710
739
    def test_empty_archive(self):
711
740
        command = cmd_baz_import()
724
753
                                       'c','+trunk')))
725
754
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 
726
755
                                                    'c1', '0.2','branch')))
 
756
        default_format = repository.RepositoryFormat.get_default_format()
 
757
        if getattr(default_format, 'rich_root_data', False):
 
758
            num_files = 21
 
759
        else:
 
760
            num_files = 20
727
761
        walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))
728
 
        self.assertEqual(22, walk_len)
 
762
        self.assertEqual(num_files, walk_len)
729
763
 
730
764
    def test_run_twice(self):
731
765
        self.make_import('c--0')
742
776
        self.make_import('c--0')
743
777
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),
744
778
                     'demo@DONOTUSE')
 
779
 
 
780
    def test_does_not_need_reuse_history(self):
 
781
        self.make_import('c--0')
 
782
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),
 
783
                     'demo@DONOTUSE')
 
784
 
 
785
    def test_encoding_flag(self):
 
786
        self.make_import('c--0')
 
787
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),
 
788
                     'demo@DONOTUSE')
 
789
        self.assertEqual(['Arch-1:demo@DONOTUSE%c--0--base-0'], 
 
790
                         Branch.open(os.path.join(self._tmpdir, 
 
791
                                     'output/c/+trunk')).revision_history())
 
792
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output2'),
 
793
                     'demo@DONOTUSE', '--encoding', 'utf-8')
 
794
        self.assertEqual(['Arch-1-utf-8:demo@DONOTUSE%c--0--base-0'], 
 
795
                         Branch.open(os.path.join(self._tmpdir, 
 
796
                                     'output2/c/+trunk')).revision_history())
 
797
        self.run_bzr('baz-import-branch', os.path.join(self._tmpdir, 'output3'),
 
798
                     'demo@DONOTUSE/c--0')
 
799
        self.assertEqual(['Arch-1:demo@DONOTUSE%c--0--base-0'], 
 
800
                         Branch.open(os.path.join(self._tmpdir, 
 
801
                                     'output3')).revision_history())
 
802
        self.run_bzr('baz-import-branch', os.path.join(self._tmpdir, 
 
803
                      'output4'), 'demo@DONOTUSE/c--0', '--encoding', 'utf-8')
 
804
        self.assertEqual(['Arch-1-utf-8:demo@DONOTUSE%c--0--base-0'], 
 
805
                         Branch.open(os.path.join(self._tmpdir, 
 
806
                                     'output4')).revision_history())