← 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-02-15 18:06:43 UTC
  • Revision ID: abentley@panoramicfeedback.com-20070215180643-v1dxrpumwghryi9r
Fix change dectection for dirstate

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