← 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-22 15:19:16 UTC
  • Revision ID: abentley@panoramicfeedback.com-20060322151916-75711de1522d1f68
Tagged BZRTOOLS commands to reduce confusion

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
23
22
except ImportError:
24
23
    pybaz = None
25
24
import os
26
 
try:
27
 
    from bzrtools import cmd_baz_import
28
 
    from bzrtools.baz_import import (import_version, revision_id,
29
 
                                      make_archive, map_file_id)
30
 
except ImportError:
31
 
    from bzrlib.plugins.bzrtools import cmd_baz_import 
32
 
    from bzrlib.plugins.bzrtools.baz_import import (import_version, 
33
 
                                                    revision_id,
34
 
                                                    make_archive,
35
 
                                                    map_file_id)
 
25
from bzrlib.plugins.bzrtools.baz_import import (import_version, revision_id, 
 
26
                                                cmd_baz_import, make_archive)
 
27
from bzrlib.errors import NoSuchRevision
36
28
import shutil
37
29
from StringIO import StringIO
38
30
import tempfile
39
31
from testresources import (TestResource, TestLoader, OptimisingTestSuite,
40
32
                               ResourcedTestCase)
41
33
    
42
 
import bzrlib
43
 
from bzrlib.errors import NoSuchRevision
44
 
try:
45
 
    from bzrtools.fai import namespace_previous
46
 
except ImportError:
47
 
    from bzrlib.plugins.bzrtools.fai import namespace_previous
 
34
from bzrlib.plugins.bzrtools.fai import namespace_previous
48
35
from bzrlib.branch import Branch
49
36
 
50
37
def test_suite():
72
59
        pybaz.set_my_id("Test User<test@example.org>")
73
60
 
74
61
        self.make_empty_import()
75
 
        self.make_utf8_log()
76
62
 
77
63
        self._empty_tag = 'demo@DONOTUSE/c--empty-tag--0'
78
 
        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0', None)
 
64
        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0')
79
65
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
80
66
            pybaz.Version(self._empty_tag))
81
67
 
82
68
        self._empty_merged_tag = 'demo@DONOTUSE/c--empty-merged-tag--0'
83
69
        self._empty_merged_tag_bzr_base = revision_id(self._empty_merged_tag 
84
 
                                                 + '--base-0', None)
 
70
                                                 + '--base-0')
85
71
        self._empty_merged_tag_bzr = revision_id(self._empty_merged_tag 
86
 
                                                 + '--patch-1', None)
 
72
                                                 + '--patch-1')
87
73
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
88
74
            pybaz.Version(self._empty_merged_tag))
89
75
        tree = pybaz.Revision(self._empty_merged_tag + '--base-0').get(
98
84
        # tree, two commits, includes merge of other branch
99
85
        self._empty_merged_tag_2 = 'demo@DONOTUSE/c--empty-tag-2--0'
100
86
        self._empty_merged_tag_2_bzr_base = revision_id(
101
 
            self._empty_merged_tag_2 + '--base-0', None)
 
87
            self._empty_merged_tag_2 + '--base-0')
102
88
        self._empty_merged_tag_2_bzr = revision_id(
103
 
            self._empty_merged_tag_2 + '--patch-1', None)
 
89
            self._empty_merged_tag_2 + '--patch-1')
104
90
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
105
91
            pybaz.Version(self._empty_merged_tag_2))
106
92
        tree = pybaz.Revision(self._empty_merged_tag_2 + '--base-0').get (
113
99
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
114
100
 
115
101
        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)
 
102
        self._bad_id_tag_bzr_base = revision_id(self._bad_id_tag + '--base-0')
 
103
        self._bad_id_tag_bzr = revision_id(self._bad_id_tag + '--patch-1')
120
104
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
121
105
            pybaz.Version(self._bad_id_tag))
122
106
        tree = pybaz.Revision(self._bad_id_tag + '--base-0').get(
136
120
    def make_import_symlink(self):
137
121
        self._import_symlink = 'demo@DONOTUSE/c--import-symlink--0'
138
122
        self._import_symlink_bzr = revision_id(
139
 
            self._import_symlink + '--base-0', None)
 
123
            self._import_symlink + '--base-0')
140
124
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
141
125
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
142
126
                               self._import_symlink)
143
 
        link_path = os.path.join(self._tmpdir, 'tree', 'alink')
144
 
        os.symlink('missing-file-name', link_path)
 
127
        os.symlink('missing-file-name',
 
128
                   os.path.join(self._tmpdir, 'tree', 'alink'))
145
129
        tree.add_tag('alink')
146
130
        id_file = open(os.path.join(tree, '.arch-ids', 'alink.id'), 'w')
147
131
        id_file.write('symlink_tag\n')
149
133
        msg = tree.log_message()
150
134
        msg["summary"] = "Import with a symlink"
151
135
        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
136
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
160
137
 
161
138
    def make_empty_import(self):
168
145
        tree.import_(msg)
169
146
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
170
147
 
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
148
    def make_missing_ancestor(self):
182
149
        self._archivegoneroot = os.path.join(self._tmpdir, 'archivegone')
183
150
        self._archive = make_archive('demo-gone@DONOTUSE',
184
151
                                     str(self._archivegoneroot))
185
152
        self._missing_import = 'demo-gone@DONOTUSE/c--import--0'
186
153
        self._missing_import_bzr = revision_id(self._missing_import 
187
 
                                                 + '--base-0', None)
 
154
                                                 + '--base-0')
188
155
        self._missing_ancestor = 'demo@DONOTUSE/c--gone--0'
189
156
        self._missing_ancestor_bzr = revision_id(self._missing_ancestor 
190
 
                                                 + '--base-0', None)
 
157
                                                 + '--base-0')
191
158
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
192
159
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
193
160
                               self._missing_import)
200
167
            pybaz.Version(self._missing_ancestor))
201
168
 
202
169
        # make an import for testing history-reuse logic.
 
170
        def collect(text):
 
171
            pass
203
172
        # note the use of a namespace layout here.
204
173
        self._missing_import_imported = os.path.join(self._tmpdir, 
205
174
                                                     'archivegone-bzr')
207
176
        os.mkdir(os.path.join(self._tmpdir, 'archivegone-bzr', 'c'))
208
177
        import_version(os.path.join(self._tmpdir, 'archivegone-bzr', 
209
178
                                    'c', 'import'),
210
 
                       pybaz.Version(self._missing_import), None)
 
179
                       pybaz.Version(self._missing_import),
 
180
                       collect)
211
181
        # and make it inaccessible
212
182
        pybaz.Archive('demo-gone@DONOTUSE').unregister()
213
183
 
214
184
    def make_inbranch_continuation(self):
215
185
        self._inbranch_tag = 'demo@DONOTUSE/c--inbranch-tag--0'
216
186
        self._inbranch_tag_base = self._inbranch_tag + '--base-0'
217
 
        self._inbranch_tag_base_bzr = revision_id(self._inbranch_tag_base, 
218
 
                                                  None)
 
187
        self._inbranch_tag_base_bzr = revision_id(self._inbranch_tag_base)
219
188
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
220
189
            pybaz.Version(self._inbranch_tag))
221
190
        self._inbranch_tag_head = self._inbranch_tag + '--patch-1'
222
 
        self._inbranch_tag_head_bzr = revision_id(self._inbranch_tag_head,
223
 
                                                  None)
 
191
        self._inbranch_tag_head_bzr = revision_id(self._inbranch_tag_head)
224
192
        pybaz.Revision(self._inbranch_tag_base).make_continuation(
225
193
            pybaz.Version(self._inbranch_tag))
226
194
 
241
209
        TestCaseInTempDir.setUp(self)
242
210
        ResourcedTestCase.setUpResources(self)
243
211
        os.environ['HOME'] = self._baz._homedir
 
212
        self.output = StringIO()
244
213
 
245
214
    def tearDown(self):
246
215
        ResourcedTestCase.tearDownResources(self)
247
216
        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
 
 
 
217
 
 
218
    def collect(self, text):
 
219
        self.output.write(text)
 
220
        self.output.write("\n")
 
221
 
263
222
    def test_import_empty(self):
264
 
        import_version('output', pybaz.Version(self._baz._import), None)
 
223
        import_version('output', pybaz.Version(self._baz._import), 
 
224
                       self.collect)
265
225
        # expected results:
266
226
        # one commit, no files, revision identifier of 
267
227
        # 'demo@DONOTUSE_c--import--0--base-0'
272
232
        rev = repo.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
273
233
        # and again.
274
234
        import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'),
275
 
                       None)
 
235
                       self.collect)
276
236
        branch2 = Branch.open('output2')
277
237
        repo2 = branch2.repository
278
238
        self.assertEqual(branch.revision_history(), branch2.revision_history())
287
247
                         "Arch-1:demo@DONOTUSE%c--import--0--base-0")
288
248
 
289
249
    def test_empty_tagged(self):
290
 
        import_version('output', pybaz.Version(self._baz._empty_tag), None)
 
250
        import_version('output', pybaz.Version(self._baz._empty_tag),
 
251
                       self.collect)
291
252
        # expected results:
292
253
        # two commits, no files, revision identifiers of 
293
254
        # 'demo@DONOTUSE_c--import--0--base-0' and
298
259
                          self._baz._empty_tag_bzr])
299
260
        rev = branch.repository.get_revision(self._baz._empty_tag_bzr)
300
261
        # and again.
301
 
        import_version('output2', pybaz.Version(self._baz._empty_tag), None)
 
262
        import_version('output2', pybaz.Version(self._baz._empty_tag),
 
263
                       self.collect)
302
264
        branch2 = Branch.open('output2')
303
265
        self.assertEqual(branch.revision_history(), branch2.revision_history())
304
266
        rev2 = branch2.repository.get_revision(self._baz._empty_tag_bzr)
312
274
        self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)
313
275
 
314
276
    def test_empty_merged_tagged(self):
315
 
        import_version('output', pybaz.Version(self._baz._empty_merged_tag), 
316
 
                       None)
 
277
        import_version('output', pybaz.Version(self._baz._empty_merged_tag),
 
278
                       self.collect)
317
279
        # expected results:
318
280
        # two commits, no files, revision identifiers of 
319
281
        # 'demo@DONOTUSE_c--import--0--base-0' and
328
290
                          self._baz._empty_merged_tag_bzr_base,
329
291
                          self._baz._empty_merged_tag_bzr])
330
292
        # and again.
331
 
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag), 
332
 
                       None)
 
293
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag),
 
294
                       self.collect)
333
295
        branch2 = Branch.open('output2')
334
296
        repo2 = branch2.repository
335
297
        # and import what we should be merged up against for checking with.
336
 
        import_version('output3', pybaz.Version(self._baz._empty_tag), None)
 
298
        import_version('output3', pybaz.Version(self._baz._empty_tag),
 
299
                       self.collect)
337
300
        branch3 = Branch.open('output3')
338
301
        
339
302
        self.assertEqual(branch.revision_history(), branch2.revision_history())
370
333
        # self.assertEqual(branch.missing_revisions(branch3), [])
371
334
        
372
335
    def test_merge_branch_with_merges(self):
373
 
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2), 
374
 
                       None)
 
336
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2),
 
337
                       self.collect)
375
338
        # expected results:
376
339
        # two commits, no files, revision identifiers of 
377
340
        # 'demo@DONOTUSE_c--import--0--base-0' and
387
350
                          self._baz._empty_merged_tag_2_bzr])
388
351
        # and again.
389
352
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2),
390
 
                       None)
 
353
                       self.collect)
391
354
        branch2 = Branch.open('output2')
392
355
        repo2 = branch2.repository
393
356
        # and import what we should be merged up against for checking with.
394
357
        import_version('output3', pybaz.Version(self._baz._empty_merged_tag),
395
 
                       None)
 
358
                       self.collect)
396
359
        branch3 = Branch.open('output3')
397
360
        
398
361
        self.assertEqual(branch.revision_history(), branch2.revision_history())
429
392
        # self.assertEqual(branch.missing_revisions(branch3), [])
430
393
        
431
394
    def test_import_symlink(self):
432
 
        import_version('output', pybaz.Version(self._baz._import_symlink), 
433
 
                       None, max_count=1)
 
395
        import_version('output', pybaz.Version(self._baz._import_symlink),
 
396
                       self.collect)
434
397
        # expected results:
435
 
        # two commits, no files, revision identifier of 
 
398
        # one commit, no files, revision identifier of 
436
399
        # 'demo@DONOTUSE_c--import--0--base-0'
437
400
        branch = Branch.open('output')
438
401
        self.assertEqual(branch.revision_history(),
440
403
        rev = branch.repository.get_revision(self._baz._import_symlink_bzr)
441
404
        # and again.
442
405
        import_version('output2', pybaz.Version(self._baz._import_symlink),
443
 
                       None, max_count=1)
 
406
                       self.collect)
444
407
        branch2 = Branch.open('output2')
445
408
        self.assertEqual(branch.revision_history(), branch2.revision_history())
446
409
        rev2 = branch2.repository.get_revision(self._baz._import_symlink_bzr)
459
422
        self.assertEqual(entry.kind, 'symlink')
460
423
        self.assertEqual(entry.symlink_target, 'missing-file-name')
461
424
 
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
425
    def test_missing_ancestor(self):
467
426
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
468
 
                       None)
 
427
                       self.collect)
469
428
        # expected results:
470
429
        # one commits, no files, revision identifiers of 
471
430
        # 'demo@DONOTUSE_c--gone--0--base-0' and
475
434
                         [self._baz._missing_ancestor_bzr])
476
435
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
477
436
        # and again.
478
 
        import_version('output2', pybaz.Version(self._baz._missing_ancestor), 
479
 
                       None)
 
437
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
 
438
                       self.collect)
480
439
        branch2 = Branch.open('output2')
481
440
        self.assertEqual(branch.revision_history(), branch2.revision_history())
482
441
        rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)
497
456
 
498
457
    def test_missing_ancestor_reusing_history(self):
499
458
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
500
 
                       None,
 
459
                       self.collect,
501
460
                       reuse_history_from=[self._baz._missing_import_imported])
502
461
        # expected results:
503
462
        # one commits, no files, revision identifiers of 
510
469
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
511
470
        # and again.
512
471
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
513
 
                       None,
 
472
                       self.collect,
514
473
                       reuse_history_from=[self._baz._missing_import_imported])
515
474
        branch2 = Branch.open('output2')
516
475
        self.assertEqual(branch.revision_history(), branch2.revision_history())
530
489
        self.assertEqual(1, len(rev.parent_ids))
531
490
 
532
491
    def test_bad_file_id(self):
533
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
 
492
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
 
493
                       self.collect)
534
494
        # expected results:
535
495
        # three commits, one files, revision identifiers of 
536
496
        # 'demo@DONOTUSE_c--import--0--base-0' ,
547
507
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
548
508
 
549
509
    def test_appending_revisions_already_present(self):
550
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None,
551
 
                       max_count=2)
 
510
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
 
511
                       self.collect, max_count=2)
552
512
        # expected results:
553
513
        # three commits, one files, revision identifiers of 
554
514
        # 'demo@DONOTUSE_c--import--0--base-0' ,
565
525
        self.assertEqual(branch.revision_history(),
566
526
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
567
527
        del branch
568
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
 
528
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
 
529
                       self.collect)
569
530
        branch = Branch.open('output')
570
531
        self.assertEqual(branch.revision_history(),
571
532
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
577
538
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
578
539
 
579
540
    def test_appending_revisions_all_already_present(self):
580
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
 
541
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
 
542
                       self.collect)
581
543
        # expected results:
582
544
        # three commits, one files, revision identifiers of 
583
545
        # 'demo@DONOTUSE_c--import--0--base-0' ,
595
557
        self.assertEqual(branch.revision_history(),
596
558
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
597
559
        del branch
598
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
 
560
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
 
561
                       self.collect)
599
562
        branch = Branch.open('output')
600
563
        self.assertEqual(branch.revision_history(),
601
564
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
607
570
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
608
571
 
609
572
    def test_inbranch_conversion(self):
610
 
        import_version('output', pybaz.Version(self._baz._inbranch_tag), None)
 
573
        import_version('output', pybaz.Version(self._baz._inbranch_tag),
 
574
                       self.collect)
611
575
        # expected results:
612
576
        # three commits, no files, revision identifiers of 
613
577
        # 'demo@DONOTUSE_c--import--0--base-0' and
620
584
                          self._baz._inbranch_tag_base_bzr,
621
585
                          self._baz._inbranch_tag_head_bzr])
622
586
        # and again.
623
 
        import_version('output2', pybaz.Version(self._baz._inbranch_tag), None)
 
587
        import_version('output2', pybaz.Version(self._baz._inbranch_tag),
 
588
                       self.collect)
624
589
        branch2 = Branch.open('output2')
625
590
        
626
591
        self.assertEqual(branch.revision_history(), branch2.revision_history())
646
611
        self.assertEqual(rev.parent_ids,
647
612
                         [self._baz._inbranch_tag_base_bzr])
648
613
 
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
614
 
661
615
class TestNamespacePrevious(TestCase):
662
616
 
687
641
        self.assertEqual(namespace_previous(self.version['versionfix-3000']),
688
642
                         self.version['versionfix-2999'])
689
643
 
690
 
 
691
644
class TestNamespaceMapping(TestCase):
692
645
 
693
646
    def test_namespace_mapping_branch(self):
710
663
class TestFileIdMapping(TestCase):
711
664
 
712
665
    def test_slash(self):
 
666
        from bzrlib.plugins.bzrtools.baz_import import map_file_id
713
667
        self.assertEqual('c%2fc', map_file_id('c/c'))
714
668
        self.assertEqual('c%25c', map_file_id('c%c'))
715
669
 
742
696
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
743
697
 
744
698
    def test_cmd_exists(self):
745
 
        from bzrlib.plugins.bzrtools import cmd_baz_import
 
699
        from bzrlib.plugins.bzrtools.baz_import import cmd_baz_import
746
700
 
747
701
    def test_empty_archive(self):
748
702
        command = cmd_baz_import()
761
715
                                       'c','+trunk')))
762
716
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 
763
717
                                                    '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
718
        walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))
770
 
        self.assertEqual(num_files, walk_len)
 
719
        self.assertEqual(22, walk_len)
771
720
 
772
721
    def test_run_twice(self):
773
722
        self.make_import('c--0')
784
733
        self.make_import('c--0')
785
734
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),
786
735
                     '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())