← 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: 2006-03-24 19:01:30 UTC
  • Revision ID: abentley@panoramicfeedback.com-20060324190130-2208c693486a8b33
Added apache index scraping to the branches command

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
20
19
from bzrlib.osutils import has_symlinks
21
20
try:
22
21
    import pybaz
24
23
    pybaz = None
25
24
import os
26
25
try:
27
 
    from bzrtools import cmd_baz_import
28
26
    from bzrtools.baz_import import (import_version, revision_id,
29
 
                                      make_archive, map_file_id)
 
27
                                     cmd_baz_import, make_archive, map_file_id)
30
28
except ImportError:
31
 
    from bzrlib.plugins.bzrtools import cmd_baz_import 
32
29
    from bzrlib.plugins.bzrtools.baz_import import (import_version, 
33
30
                                                    revision_id,
 
31
                                                    cmd_baz_import,
34
32
                                                    make_archive,
35
33
                                                    map_file_id)
 
34
from bzrlib.errors import NoSuchRevision
36
35
import shutil
37
36
from StringIO import StringIO
38
37
import tempfile
39
38
from testresources import (TestResource, TestLoader, OptimisingTestSuite,
40
39
                               ResourcedTestCase)
41
40
    
42
 
import bzrlib
43
 
from bzrlib.errors import NoSuchRevision
44
41
try:
45
42
    from bzrtools.fai import namespace_previous
46
43
except ImportError:
72
69
        pybaz.set_my_id("Test User<test@example.org>")
73
70
 
74
71
        self.make_empty_import()
75
 
        self.make_utf8_log()
76
72
 
77
73
        self._empty_tag = 'demo@DONOTUSE/c--empty-tag--0'
78
 
        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0', None)
 
74
        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0')
79
75
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
80
76
            pybaz.Version(self._empty_tag))
81
77
 
82
78
        self._empty_merged_tag = 'demo@DONOTUSE/c--empty-merged-tag--0'
83
79
        self._empty_merged_tag_bzr_base = revision_id(self._empty_merged_tag 
84
 
                                                 + '--base-0', None)
 
80
                                                 + '--base-0')
85
81
        self._empty_merged_tag_bzr = revision_id(self._empty_merged_tag 
86
 
                                                 + '--patch-1', None)
 
82
                                                 + '--patch-1')
87
83
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
88
84
            pybaz.Version(self._empty_merged_tag))
89
85
        tree = pybaz.Revision(self._empty_merged_tag + '--base-0').get(
98
94
        # tree, two commits, includes merge of other branch
99
95
        self._empty_merged_tag_2 = 'demo@DONOTUSE/c--empty-tag-2--0'
100
96
        self._empty_merged_tag_2_bzr_base = revision_id(
101
 
            self._empty_merged_tag_2 + '--base-0', None)
 
97
            self._empty_merged_tag_2 + '--base-0')
102
98
        self._empty_merged_tag_2_bzr = revision_id(
103
 
            self._empty_merged_tag_2 + '--patch-1', None)
 
99
            self._empty_merged_tag_2 + '--patch-1')
104
100
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
105
101
            pybaz.Version(self._empty_merged_tag_2))
106
102
        tree = pybaz.Revision(self._empty_merged_tag_2 + '--base-0').get (
113
109
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
114
110
 
115
111
        self._bad_id_tag = 'demo@DONOTUSE/c--bad-id--0'
116
 
        self._bad_id_tag_bzr_base = revision_id(self._bad_id_tag + '--base-0',
117
 
                                                None)
118
 
        self._bad_id_tag_bzr = revision_id(self._bad_id_tag + '--patch-1',
119
 
                                           None)
 
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')
120
114
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
121
115
            pybaz.Version(self._bad_id_tag))
122
116
        tree = pybaz.Revision(self._bad_id_tag + '--base-0').get(
136
130
    def make_import_symlink(self):
137
131
        self._import_symlink = 'demo@DONOTUSE/c--import-symlink--0'
138
132
        self._import_symlink_bzr = revision_id(
139
 
            self._import_symlink + '--base-0', None)
 
133
            self._import_symlink + '--base-0')
140
134
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
141
135
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
142
136
                               self._import_symlink)
143
 
        link_path = os.path.join(self._tmpdir, 'tree', 'alink')
144
 
        os.symlink('missing-file-name', link_path)
 
137
        os.symlink('missing-file-name',
 
138
                   os.path.join(self._tmpdir, 'tree', 'alink'))
145
139
        tree.add_tag('alink')
146
140
        id_file = open(os.path.join(tree, '.arch-ids', 'alink.id'), 'w')
147
141
        id_file.write('symlink_tag\n')
149
143
        msg = tree.log_message()
150
144
        msg["summary"] = "Import with a symlink"
151
145
        tree.import_(msg)
152
 
        os.unlink(link_path)
153
 
        f = file(link_path, 'w')
154
 
        f.write('Not a symlink no more!')
155
 
        f.close()
156
 
        msg = tree.log_message()
157
 
        msg["summary"] = "Turn a symlink into a file"
158
 
        tree.commit(msg)
159
146
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
160
147
 
161
148
    def make_empty_import(self):
168
155
        tree.import_(msg)
169
156
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
170
157
 
171
 
    def make_utf8_log(self):
172
 
        self._utf8 = 'demo@DONOTUSE/c--utf8--0'
173
 
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
174
 
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
175
 
                               self._utf8)
176
 
        msg = tree.log_message()
177
 
        msg["summary"] = u"I am importing now\u1234".encode('utf-8')
178
 
        tree.import_(msg)
179
 
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
180
 
 
181
158
    def make_missing_ancestor(self):
182
159
        self._archivegoneroot = os.path.join(self._tmpdir, 'archivegone')
183
160
        self._archive = make_archive('demo-gone@DONOTUSE',
184
161
                                     str(self._archivegoneroot))
185
162
        self._missing_import = 'demo-gone@DONOTUSE/c--import--0'
186
163
        self._missing_import_bzr = revision_id(self._missing_import 
187
 
                                                 + '--base-0', None)
 
164
                                                 + '--base-0')
188
165
        self._missing_ancestor = 'demo@DONOTUSE/c--gone--0'
189
166
        self._missing_ancestor_bzr = revision_id(self._missing_ancestor 
190
 
                                                 + '--base-0', None)
 
167
                                                 + '--base-0')
191
168
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
192
169
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
193
170
                               self._missing_import)
200
177
            pybaz.Version(self._missing_ancestor))
201
178
 
202
179
        # make an import for testing history-reuse logic.
 
180
        def collect(text):
 
181
            pass
203
182
        # note the use of a namespace layout here.
204
183
        self._missing_import_imported = os.path.join(self._tmpdir, 
205
184
                                                     'archivegone-bzr')
207
186
        os.mkdir(os.path.join(self._tmpdir, 'archivegone-bzr', 'c'))
208
187
        import_version(os.path.join(self._tmpdir, 'archivegone-bzr', 
209
188
                                    'c', 'import'),
210
 
                       pybaz.Version(self._missing_import), None)
 
189
                       pybaz.Version(self._missing_import),
 
190
                       collect)
211
191
        # and make it inaccessible
212
192
        pybaz.Archive('demo-gone@DONOTUSE').unregister()
213
193
 
214
194
    def make_inbranch_continuation(self):
215
195
        self._inbranch_tag = 'demo@DONOTUSE/c--inbranch-tag--0'
216
196
        self._inbranch_tag_base = self._inbranch_tag + '--base-0'
217
 
        self._inbranch_tag_base_bzr = revision_id(self._inbranch_tag_base, 
218
 
                                                  None)
 
197
        self._inbranch_tag_base_bzr = revision_id(self._inbranch_tag_base)
219
198
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
220
199
            pybaz.Version(self._inbranch_tag))
221
200
        self._inbranch_tag_head = self._inbranch_tag + '--patch-1'
222
 
        self._inbranch_tag_head_bzr = revision_id(self._inbranch_tag_head,
223
 
                                                  None)
 
201
        self._inbranch_tag_head_bzr = revision_id(self._inbranch_tag_head)
224
202
        pybaz.Revision(self._inbranch_tag_base).make_continuation(
225
203
            pybaz.Version(self._inbranch_tag))
226
204
 
241
219
        TestCaseInTempDir.setUp(self)
242
220
        ResourcedTestCase.setUpResources(self)
243
221
        os.environ['HOME'] = self._baz._homedir
 
222
        self.output = StringIO()
244
223
 
245
224
    def tearDown(self):
246
225
        ResourcedTestCase.tearDownResources(self)
247
226
        TestCaseInTempDir.tearDown(self)
248
 
 
249
 
    def test_import_utf8(self):
250
 
        import_version('output', pybaz.Version(self._baz._utf8), None)
251
 
        branch = Branch.open('output')
252
 
        plain_revid = 'Arch-1:demo@DONOTUSE%c--utf8--0--base-0'
253
 
        self.assertEqual([plain_revid], branch.revision_history())
254
 
        self.assertEqual(u'I am importing now\ufffd\ufffd\ufffd',
255
 
                         branch.repository.get_revision(plain_revid).message)
256
 
        import_version('output2', pybaz.Version(self._baz._utf8), 'utf-8')
257
 
        branch2 = Branch.open('output2')
258
 
        utf8_revid = 'Arch-1-utf-8:demo@DONOTUSE%c--utf8--0--base-0'
259
 
        self.assertEqual([utf8_revid], branch2.revision_history())
260
 
        self.assertEqual(u'I am importing now\u1234',
261
 
                         branch2.repository.get_revision(utf8_revid).message)
262
 
 
 
227
 
 
228
    def collect(self, text):
 
229
        self.output.write(text)
 
230
        self.output.write("\n")
 
231
 
263
232
    def test_import_empty(self):
264
 
        import_version('output', pybaz.Version(self._baz._import), None)
 
233
        import_version('output', pybaz.Version(self._baz._import), 
 
234
                       self.collect)
265
235
        # expected results:
266
236
        # one commit, no files, revision identifier of 
267
237
        # 'demo@DONOTUSE_c--import--0--base-0'
272
242
        rev = repo.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
273
243
        # and again.
274
244
        import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'),
275
 
                       None)
 
245
                       self.collect)
276
246
        branch2 = Branch.open('output2')
277
247
        repo2 = branch2.repository
278
248
        self.assertEqual(branch.revision_history(), branch2.revision_history())
287
257
                         "Arch-1:demo@DONOTUSE%c--import--0--base-0")
288
258
 
289
259
    def test_empty_tagged(self):
290
 
        import_version('output', pybaz.Version(self._baz._empty_tag), None)
 
260
        import_version('output', pybaz.Version(self._baz._empty_tag),
 
261
                       self.collect)
291
262
        # expected results:
292
263
        # two commits, no files, revision identifiers of 
293
264
        # 'demo@DONOTUSE_c--import--0--base-0' and
298
269
                          self._baz._empty_tag_bzr])
299
270
        rev = branch.repository.get_revision(self._baz._empty_tag_bzr)
300
271
        # and again.
301
 
        import_version('output2', pybaz.Version(self._baz._empty_tag), None)
 
272
        import_version('output2', pybaz.Version(self._baz._empty_tag),
 
273
                       self.collect)
302
274
        branch2 = Branch.open('output2')
303
275
        self.assertEqual(branch.revision_history(), branch2.revision_history())
304
276
        rev2 = branch2.repository.get_revision(self._baz._empty_tag_bzr)
312
284
        self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)
313
285
 
314
286
    def test_empty_merged_tagged(self):
315
 
        import_version('output', pybaz.Version(self._baz._empty_merged_tag), 
316
 
                       None)
 
287
        import_version('output', pybaz.Version(self._baz._empty_merged_tag),
 
288
                       self.collect)
317
289
        # expected results:
318
290
        # two commits, no files, revision identifiers of 
319
291
        # 'demo@DONOTUSE_c--import--0--base-0' and
328
300
                          self._baz._empty_merged_tag_bzr_base,
329
301
                          self._baz._empty_merged_tag_bzr])
330
302
        # and again.
331
 
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag), 
332
 
                       None)
 
303
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag),
 
304
                       self.collect)
333
305
        branch2 = Branch.open('output2')
334
306
        repo2 = branch2.repository
335
307
        # and import what we should be merged up against for checking with.
336
 
        import_version('output3', pybaz.Version(self._baz._empty_tag), None)
 
308
        import_version('output3', pybaz.Version(self._baz._empty_tag),
 
309
                       self.collect)
337
310
        branch3 = Branch.open('output3')
338
311
        
339
312
        self.assertEqual(branch.revision_history(), branch2.revision_history())
370
343
        # self.assertEqual(branch.missing_revisions(branch3), [])
371
344
        
372
345
    def test_merge_branch_with_merges(self):
373
 
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2), 
374
 
                       None)
 
346
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2),
 
347
                       self.collect)
375
348
        # expected results:
376
349
        # two commits, no files, revision identifiers of 
377
350
        # 'demo@DONOTUSE_c--import--0--base-0' and
387
360
                          self._baz._empty_merged_tag_2_bzr])
388
361
        # and again.
389
362
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2),
390
 
                       None)
 
363
                       self.collect)
391
364
        branch2 = Branch.open('output2')
392
365
        repo2 = branch2.repository
393
366
        # and import what we should be merged up against for checking with.
394
367
        import_version('output3', pybaz.Version(self._baz._empty_merged_tag),
395
 
                       None)
 
368
                       self.collect)
396
369
        branch3 = Branch.open('output3')
397
370
        
398
371
        self.assertEqual(branch.revision_history(), branch2.revision_history())
429
402
        # self.assertEqual(branch.missing_revisions(branch3), [])
430
403
        
431
404
    def test_import_symlink(self):
432
 
        import_version('output', pybaz.Version(self._baz._import_symlink), 
433
 
                       None, max_count=1)
 
405
        import_version('output', pybaz.Version(self._baz._import_symlink),
 
406
                       self.collect)
434
407
        # expected results:
435
 
        # two commits, no files, revision identifier of 
 
408
        # one commit, no files, revision identifier of 
436
409
        # 'demo@DONOTUSE_c--import--0--base-0'
437
410
        branch = Branch.open('output')
438
411
        self.assertEqual(branch.revision_history(),
440
413
        rev = branch.repository.get_revision(self._baz._import_symlink_bzr)
441
414
        # and again.
442
415
        import_version('output2', pybaz.Version(self._baz._import_symlink),
443
 
                       None, max_count=1)
 
416
                       self.collect)
444
417
        branch2 = Branch.open('output2')
445
418
        self.assertEqual(branch.revision_history(), branch2.revision_history())
446
419
        rev2 = branch2.repository.get_revision(self._baz._import_symlink_bzr)
459
432
        self.assertEqual(entry.kind, 'symlink')
460
433
        self.assertEqual(entry.symlink_target, 'missing-file-name')
461
434
 
462
 
        # current bzr doesn't handle type changes
463
 
        self.assertRaises(AssertionError, import_version, 'output3',
464
 
                          pybaz.Version(self._baz._import_symlink), None)
465
 
 
466
435
    def test_missing_ancestor(self):
467
436
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
468
 
                       None)
 
437
                       self.collect)
469
438
        # expected results:
470
439
        # one commits, no files, revision identifiers of 
471
440
        # 'demo@DONOTUSE_c--gone--0--base-0' and
475
444
                         [self._baz._missing_ancestor_bzr])
476
445
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
477
446
        # and again.
478
 
        import_version('output2', pybaz.Version(self._baz._missing_ancestor), 
479
 
                       None)
 
447
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
 
448
                       self.collect)
480
449
        branch2 = Branch.open('output2')
481
450
        self.assertEqual(branch.revision_history(), branch2.revision_history())
482
451
        rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)
497
466
 
498
467
    def test_missing_ancestor_reusing_history(self):
499
468
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
500
 
                       None,
 
469
                       self.collect,
501
470
                       reuse_history_from=[self._baz._missing_import_imported])
502
471
        # expected results:
503
472
        # one commits, no files, revision identifiers of 
510
479
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
511
480
        # and again.
512
481
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
513
 
                       None,
 
482
                       self.collect,
514
483
                       reuse_history_from=[self._baz._missing_import_imported])
515
484
        branch2 = Branch.open('output2')
516
485
        self.assertEqual(branch.revision_history(), branch2.revision_history())
530
499
        self.assertEqual(1, len(rev.parent_ids))
531
500
 
532
501
    def test_bad_file_id(self):
533
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
 
502
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
 
503
                       self.collect)
534
504
        # expected results:
535
505
        # three commits, one files, revision identifiers of 
536
506
        # 'demo@DONOTUSE_c--import--0--base-0' ,
547
517
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
548
518
 
549
519
    def test_appending_revisions_already_present(self):
550
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None,
551
 
                       max_count=2)
 
520
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
 
521
                       self.collect, max_count=2)
552
522
        # expected results:
553
523
        # three commits, one files, revision identifiers of 
554
524
        # 'demo@DONOTUSE_c--import--0--base-0' ,
565
535
        self.assertEqual(branch.revision_history(),
566
536
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
567
537
        del branch
568
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
 
538
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
 
539
                       self.collect)
569
540
        branch = Branch.open('output')
570
541
        self.assertEqual(branch.revision_history(),
571
542
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
577
548
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
578
549
 
579
550
    def test_appending_revisions_all_already_present(self):
580
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
 
551
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
 
552
                       self.collect)
581
553
        # expected results:
582
554
        # three commits, one files, revision identifiers of 
583
555
        # 'demo@DONOTUSE_c--import--0--base-0' ,
595
567
        self.assertEqual(branch.revision_history(),
596
568
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
597
569
        del branch
598
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
 
570
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
 
571
                       self.collect)
599
572
        branch = Branch.open('output')
600
573
        self.assertEqual(branch.revision_history(),
601
574
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
607
580
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
608
581
 
609
582
    def test_inbranch_conversion(self):
610
 
        import_version('output', pybaz.Version(self._baz._inbranch_tag), None)
 
583
        import_version('output', pybaz.Version(self._baz._inbranch_tag),
 
584
                       self.collect)
611
585
        # expected results:
612
586
        # three commits, no files, revision identifiers of 
613
587
        # 'demo@DONOTUSE_c--import--0--base-0' and
620
594
                          self._baz._inbranch_tag_base_bzr,
621
595
                          self._baz._inbranch_tag_head_bzr])
622
596
        # and again.
623
 
        import_version('output2', pybaz.Version(self._baz._inbranch_tag), None)
 
597
        import_version('output2', pybaz.Version(self._baz._inbranch_tag),
 
598
                       self.collect)
624
599
        branch2 = Branch.open('output2')
625
600
        
626
601
        self.assertEqual(branch.revision_history(), branch2.revision_history())
646
621
        self.assertEqual(rev.parent_ids,
647
622
                         [self._baz._inbranch_tag_base_bzr])
648
623
 
649
 
    def test_no_commits_same_as_missing(self):
650
 
        path = 'output'
651
 
        os.mkdir(path)
652
 
        branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(path)
653
 
        import_version(path, pybaz.Version(self._baz._import), None)
654
 
        # expected results:
655
 
        # one commit, revision identifier of 
656
 
        # 'demo@DONOTUSE_c--import--0--base-0'
657
 
        self.assertEqual(branch.revision_history(),
658
 
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
659
 
 
660
624
 
661
625
class TestNamespacePrevious(TestCase):
662
626
 
687
651
        self.assertEqual(namespace_previous(self.version['versionfix-3000']),
688
652
                         self.version['versionfix-2999'])
689
653
 
690
 
 
691
654
class TestNamespaceMapping(TestCase):
692
655
 
693
656
    def test_namespace_mapping_branch(self):
742
705
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
743
706
 
744
707
    def test_cmd_exists(self):
745
 
        from bzrlib.plugins.bzrtools import cmd_baz_import
 
708
        from bzrlib.plugins.bzrtools.baz_import import cmd_baz_import
746
709
 
747
710
    def test_empty_archive(self):
748
711
        command = cmd_baz_import()
761
724
                                       'c','+trunk')))
762
725
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 
763
726
                                                    'c1', '0.2','branch')))
764
 
        default_format = repository.RepositoryFormat.get_default_format()
765
 
        if getattr(default_format, 'rich_root_data', False):
766
 
            num_files = 21
767
 
        else:
768
 
            num_files = 20
769
727
        walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))
770
 
        self.assertEqual(num_files, walk_len)
 
728
        self.assertEqual(22, walk_len)
771
729
 
772
730
    def test_run_twice(self):
773
731
        self.make_import('c--0')
784
742
        self.make_import('c--0')
785
743
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),
786
744
                     'demo@DONOTUSE')
787
 
 
788
 
    def test_does_not_need_reuse_history(self):
789
 
        self.make_import('c--0')
790
 
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),
791
 
                     'demo@DONOTUSE')
792
 
 
793
 
    def test_encoding_flag(self):
794
 
        self.make_import('c--0')
795
 
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),
796
 
                     'demo@DONOTUSE')
797
 
        self.assertEqual(['Arch-1:demo@DONOTUSE%c--0--base-0'], 
798
 
                         Branch.open(os.path.join(self._tmpdir, 
799
 
                                     'output/c/+trunk')).revision_history())
800
 
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output2'),
801
 
                     'demo@DONOTUSE', '--encoding', 'utf-8')
802
 
        self.assertEqual(['Arch-1-utf-8:demo@DONOTUSE%c--0--base-0'], 
803
 
                         Branch.open(os.path.join(self._tmpdir, 
804
 
                                     'output2/c/+trunk')).revision_history())
805
 
        self.run_bzr('baz-import-branch', os.path.join(self._tmpdir, 'output3'),
806
 
                     'demo@DONOTUSE/c--0')
807
 
        self.assertEqual(['Arch-1:demo@DONOTUSE%c--0--base-0'], 
808
 
                         Branch.open(os.path.join(self._tmpdir, 
809
 
                                     'output3')).revision_history())
810
 
        self.run_bzr('baz-import-branch', os.path.join(self._tmpdir, 
811
 
                      'output4'), 'demo@DONOTUSE/c--0', '--encoding', 'utf-8')
812
 
        self.assertEqual(['Arch-1-utf-8:demo@DONOTUSE%c--0--base-0'], 
813
 
                         Branch.open(os.path.join(self._tmpdir, 
814
 
                                     'output4')).revision_history())