← 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: 2008-03-20 15:36:35 UTC
  • Revision ID: aaron@aaronbentley.com-20080320153635-ywgk5968qpopub9y
cbranch creates parent directories as needed

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)
 
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)
34
31
import shutil
35
32
from StringIO import StringIO
36
33
import tempfile
37
34
from testresources import (TestResource, TestLoader, OptimisingTestSuite,
38
35
                               ResourcedTestCase)
39
 
    
 
36
 
40
37
import bzrlib
41
38
from bzrlib.errors import NoSuchRevision
42
 
try:
43
 
    from bzrtools.fai import namespace_previous
44
 
except ImportError:
45
 
    from bzrlib.plugins.bzrtools.fai import namespace_previous
 
39
from bzrlib.plugins.bzrtools.fai import namespace_previous
46
40
from bzrlib.branch import Branch
47
41
 
48
42
def test_suite():
50
44
        from unittest import TestSuite
51
45
        return TestSuite()
52
46
    return TestLoader().loadTestsFromName(__name__)
53
 
 
 
47
 
54
48
 
55
49
class BazTreeResource(TestResource):
56
50
 
70
64
        pybaz.set_my_id("Test User<test@example.org>")
71
65
 
72
66
        self.make_empty_import()
 
67
        self.make_utf8_log()
73
68
 
74
69
        self._empty_tag = 'demo@DONOTUSE/c--empty-tag--0'
75
 
        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0')
 
70
        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0', None)
76
71
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
77
72
            pybaz.Version(self._empty_tag))
78
73
 
79
74
        self._empty_merged_tag = 'demo@DONOTUSE/c--empty-merged-tag--0'
80
 
        self._empty_merged_tag_bzr_base = revision_id(self._empty_merged_tag 
81
 
                                                 + '--base-0')
82
 
        self._empty_merged_tag_bzr = revision_id(self._empty_merged_tag 
83
 
                                                 + '--patch-1')
 
75
        self._empty_merged_tag_bzr_base = revision_id(self._empty_merged_tag
 
76
                                                 + '--base-0', None)
 
77
        self._empty_merged_tag_bzr = revision_id(self._empty_merged_tag
 
78
                                                 + '--patch-1', None)
84
79
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
85
80
            pybaz.Version(self._empty_merged_tag))
86
81
        tree = pybaz.Revision(self._empty_merged_tag + '--base-0').get(
91
86
        msg["summary"]="did a merge, yarh"
92
87
        tree.commit(msg)
93
88
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
94
 
        
 
89
 
95
90
        # tree, two commits, includes merge of other branch
96
91
        self._empty_merged_tag_2 = 'demo@DONOTUSE/c--empty-tag-2--0'
97
92
        self._empty_merged_tag_2_bzr_base = revision_id(
98
 
            self._empty_merged_tag_2 + '--base-0')
 
93
            self._empty_merged_tag_2 + '--base-0', None)
99
94
        self._empty_merged_tag_2_bzr = revision_id(
100
 
            self._empty_merged_tag_2 + '--patch-1')
 
95
            self._empty_merged_tag_2 + '--patch-1', None)
101
96
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
102
97
            pybaz.Version(self._empty_merged_tag_2))
103
98
        tree = pybaz.Revision(self._empty_merged_tag_2 + '--base-0').get (
110
105
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
111
106
 
112
107
        self._bad_id_tag = 'demo@DONOTUSE/c--bad-id--0'
113
 
        self._bad_id_tag_bzr_base = revision_id(self._bad_id_tag + '--base-0')
114
 
        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)
115
112
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
116
113
            pybaz.Version(self._bad_id_tag))
117
114
        tree = pybaz.Revision(self._bad_id_tag + '--base-0').get(
118
115
            os.path.join(self._tmpdir, 'tree'))
119
116
        from bzrlib.plugins.bzrtools.baz_import import add_file
120
 
        add_file(os.path.join(self._tmpdir,'tree/path'), 'text', 
 
117
        add_file(os.path.join(self._tmpdir,'tree/path'), 'text',
121
118
                 'this_id/needs%escaping')
122
119
        msg = tree.log_message()
123
120
        msg["summary"] = "commit something which needs escaping."
131
128
    def make_import_symlink(self):
132
129
        self._import_symlink = 'demo@DONOTUSE/c--import-symlink--0'
133
130
        self._import_symlink_bzr = revision_id(
134
 
            self._import_symlink + '--base-0')
 
131
            self._import_symlink + '--base-0', None)
135
132
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
136
133
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
137
134
                               self._import_symlink)
156
153
    def make_empty_import(self):
157
154
        self._import = 'demo@DONOTUSE/c--import--0'
158
155
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
159
 
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
156
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
160
157
                               self._import)
161
158
        msg = tree.log_message()
162
159
        msg["summary"] = "I am importing now"
163
160
        tree.import_(msg)
164
161
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
165
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
 
166
173
    def make_missing_ancestor(self):
167
174
        self._archivegoneroot = os.path.join(self._tmpdir, 'archivegone')
168
175
        self._archive = make_archive('demo-gone@DONOTUSE',
169
176
                                     str(self._archivegoneroot))
170
177
        self._missing_import = 'demo-gone@DONOTUSE/c--import--0'
171
 
        self._missing_import_bzr = revision_id(self._missing_import 
172
 
                                                 + '--base-0')
 
178
        self._missing_import_bzr = revision_id(self._missing_import
 
179
                                                 + '--base-0', None)
173
180
        self._missing_ancestor = 'demo@DONOTUSE/c--gone--0'
174
 
        self._missing_ancestor_bzr = revision_id(self._missing_ancestor 
175
 
                                                 + '--base-0')
 
181
        self._missing_ancestor_bzr = revision_id(self._missing_ancestor
 
182
                                                 + '--base-0', None)
176
183
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
177
 
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
184
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
178
185
                               self._missing_import)
179
186
        msg = tree.log_message()
180
187
        msg["summary"] = "I am importing now"
186
193
 
187
194
        # make an import for testing history-reuse logic.
188
195
        # note the use of a namespace layout here.
189
 
        self._missing_import_imported = os.path.join(self._tmpdir, 
 
196
        self._missing_import_imported = os.path.join(self._tmpdir,
190
197
                                                     'archivegone-bzr')
191
198
        os.mkdir(os.path.join(self._tmpdir, 'archivegone-bzr'))
192
199
        os.mkdir(os.path.join(self._tmpdir, 'archivegone-bzr', 'c'))
193
 
        import_version(os.path.join(self._tmpdir, 'archivegone-bzr', 
 
200
        import_version(os.path.join(self._tmpdir, 'archivegone-bzr',
194
201
                                    'c', 'import'),
195
 
                       pybaz.Version(self._missing_import))
 
202
                       pybaz.Version(self._missing_import), None)
196
203
        # and make it inaccessible
197
204
        pybaz.Archive('demo-gone@DONOTUSE').unregister()
198
205
 
199
206
    def make_inbranch_continuation(self):
200
207
        self._inbranch_tag = 'demo@DONOTUSE/c--inbranch-tag--0'
201
208
        self._inbranch_tag_base = self._inbranch_tag + '--base-0'
202
 
        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)
203
211
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
204
212
            pybaz.Version(self._inbranch_tag))
205
213
        self._inbranch_tag_head = self._inbranch_tag + '--patch-1'
206
 
        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)
207
216
        pybaz.Revision(self._inbranch_tag_base).make_continuation(
208
217
            pybaz.Version(self._inbranch_tag))
209
218
 
228
237
    def tearDown(self):
229
238
        ResourcedTestCase.tearDownResources(self)
230
239
        TestCaseInTempDir.tearDown(self)
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))
 
256
        import_version('output', pybaz.Version(self._baz._import), None)
234
257
        # expected results:
235
 
        # one commit, no files, revision identifier of 
 
258
        # one commit, no files, revision identifier of
236
259
        # 'demo@DONOTUSE_c--import--0--base-0'
237
260
        branch = Branch.open('output')
238
261
        repo = branch.repository
240
263
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
241
264
        rev = repo.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
242
265
        # and again.
243
 
        import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'))
 
266
        import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'),
 
267
                       None)
244
268
        branch2 = Branch.open('output2')
245
269
        repo2 = branch2.repository
246
270
        self.assertEqual(branch.revision_history(), branch2.revision_history())
255
279
                         "Arch-1:demo@DONOTUSE%c--import--0--base-0")
256
280
 
257
281
    def test_empty_tagged(self):
258
 
        import_version('output', pybaz.Version(self._baz._empty_tag))
 
282
        import_version('output', pybaz.Version(self._baz._empty_tag), None)
259
283
        # expected results:
260
 
        # two commits, no files, revision identifiers of 
 
284
        # two commits, no files, revision identifiers of
261
285
        # 'demo@DONOTUSE_c--import--0--base-0' and
262
286
        # self._baz._empty_tag_bzr
263
287
        branch = Branch.open('output')
266
290
                          self._baz._empty_tag_bzr])
267
291
        rev = branch.repository.get_revision(self._baz._empty_tag_bzr)
268
292
        # and again.
269
 
        import_version('output2', pybaz.Version(self._baz._empty_tag))
 
293
        import_version('output2', pybaz.Version(self._baz._empty_tag), None)
270
294
        branch2 = Branch.open('output2')
271
295
        self.assertEqual(branch.revision_history(), branch2.revision_history())
272
296
        rev2 = branch2.repository.get_revision(self._baz._empty_tag_bzr)
275
299
 
276
300
        # and we should get some expected values:
277
301
        self.assertEqual(rev.committer, "Test User<test@example.org>")
278
 
        self.assertEqual(rev.message, 
 
302
        self.assertEqual(rev.message,
279
303
                         "tag of demo@DONOTUSE/c--import--0--base-0")
280
304
        self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)
281
305
 
282
306
    def test_empty_merged_tagged(self):
283
 
        import_version('output', pybaz.Version(self._baz._empty_merged_tag))
 
307
        import_version('output', pybaz.Version(self._baz._empty_merged_tag),
 
308
                       None)
284
309
        # expected results:
285
 
        # two commits, no files, revision identifiers of 
 
310
        # two commits, no files, revision identifiers of
286
311
        # 'demo@DONOTUSE_c--import--0--base-0' and
287
312
        # self._baz._empty_merged_tag_bzr_base
288
313
        # self._baz._empty_merged_tag_bzr
295
320
                          self._baz._empty_merged_tag_bzr_base,
296
321
                          self._baz._empty_merged_tag_bzr])
297
322
        # and again.
298
 
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag))
 
323
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag),
 
324
                       None)
299
325
        branch2 = Branch.open('output2')
300
326
        repo2 = branch2.repository
301
327
        # and import what we should be merged up against for checking with.
302
 
        import_version('output3', pybaz.Version(self._baz._empty_tag))
 
328
        import_version('output3', pybaz.Version(self._baz._empty_tag), None)
303
329
        branch3 = Branch.open('output3')
304
 
        
 
330
 
305
331
        self.assertEqual(branch.revision_history(), branch2.revision_history())
306
 
        self.assertNotEqual(branch.revision_history(), 
 
332
        self.assertNotEqual(branch.revision_history(),
307
333
                            branch3.revision_history())
308
334
        # check revisions in the history.
309
335
        rev = repo.get_revision(self._baz._empty_merged_tag_bzr_base)
312
338
        self.assertEqual(rev, rev2)
313
339
        # and we should get some expected values:
314
340
        self.assertEqual(rev.committer, "Test User<test@example.org>")
315
 
        self.assertEqual(rev.message, 
 
341
        self.assertEqual(rev.message,
316
342
                         "tag of demo@DONOTUSE/c--import--0--base-0")
317
343
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr_base)
318
344
        self.assertEqual(['Arch-1:demo@DONOTUSE%c--import--0--base-0'],
331
357
                         self._baz._empty_merged_tag_bzr_base)
332
358
        self.assertEqual(rev.parent_ids[1], self._baz._empty_tag_bzr)
333
359
 
334
 
        # this tree should have nothing missing from that tree.   
 
360
        # this tree should have nothing missing from that tree.
335
361
        # FIXME there is no code for this right now.
336
362
        # self.assertEqual(branch.missing_revisions(branch3), [])
337
 
        
 
363
 
338
364
    def test_merge_branch_with_merges(self):
339
 
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2))
 
365
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2),
 
366
                       None)
340
367
        # expected results:
341
 
        # two commits, no files, revision identifiers of 
 
368
        # two commits, no files, revision identifiers of
342
369
        # 'demo@DONOTUSE_c--import--0--base-0' and
343
370
        # self._baz._empty_merged_tag_2_bzr_base
344
371
        # self._baz._empty_merged_tag_2_bzr
351
378
                          self._baz._empty_merged_tag_2_bzr_base,
352
379
                          self._baz._empty_merged_tag_2_bzr])
353
380
        # and again.
354
 
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2))
 
381
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2),
 
382
                       None)
355
383
        branch2 = Branch.open('output2')
356
384
        repo2 = branch2.repository
357
385
        # and import what we should be merged up against for checking with.
358
 
        import_version('output3', pybaz.Version(self._baz._empty_merged_tag))
 
386
        import_version('output3', pybaz.Version(self._baz._empty_merged_tag),
 
387
                       None)
359
388
        branch3 = Branch.open('output3')
360
 
        
 
389
 
361
390
        self.assertEqual(branch.revision_history(), branch2.revision_history())
362
 
        self.assertNotEqual(branch.revision_history(), 
 
391
        self.assertNotEqual(branch.revision_history(),
363
392
                            branch3.revision_history())
364
393
        # check revisions in the history.
365
394
        rev = repo.get_revision(self._baz._empty_merged_tag_2_bzr_base)
368
397
        self.assertEqual(rev, rev2)
369
398
        # and we should get some expected values:
370
399
        self.assertEqual(rev.committer, "Test User<test@example.org>")
371
 
        self.assertEqual(rev.message, 
 
400
        self.assertEqual(rev.message,
372
401
                         "tag of demo@DONOTUSE/c--import--0--base-0")
373
 
        self.assertEqual(rev.revision_id, 
 
402
        self.assertEqual(rev.revision_id,
374
403
                         self._baz._empty_merged_tag_2_bzr_base)
375
404
 
376
405
        # check next revisions in the history.
387
416
        self.assertEqual(rev.parent_ids[1],
388
417
                         self._baz._empty_merged_tag_bzr)
389
418
 
390
 
        # this tree should have nothing missing from that tree.   
 
419
        # this tree should have nothing missing from that tree.
391
420
        # FIXME there is no code for this right now.
392
421
        # self.assertEqual(branch.missing_revisions(branch3), [])
393
 
        
 
422
 
394
423
    def test_import_symlink(self):
395
 
        import_version('output', pybaz.Version(self._baz._import_symlink), 
396
 
                       max_count=1)
 
424
        import_version('output', pybaz.Version(self._baz._import_symlink),
 
425
                       None, max_count=1)
397
426
        # expected results:
398
 
        # two commits, no files, revision identifier of 
 
427
        # two commits, no files, revision identifier of
399
428
        # 'demo@DONOTUSE_c--import--0--base-0'
400
429
        branch = Branch.open('output')
401
430
        self.assertEqual(branch.revision_history(),
403
432
        rev = branch.repository.get_revision(self._baz._import_symlink_bzr)
404
433
        # and again.
405
434
        import_version('output2', pybaz.Version(self._baz._import_symlink),
406
 
                       max_count=1)
 
435
                       None, max_count=1)
407
436
        branch2 = Branch.open('output2')
408
437
        self.assertEqual(branch.revision_history(), branch2.revision_history())
409
438
        rev2 = branch2.repository.get_revision(self._baz._import_symlink_bzr)
422
451
        self.assertEqual(entry.kind, 'symlink')
423
452
        self.assertEqual(entry.symlink_target, 'missing-file-name')
424
453
 
425
 
        # current bzr doesn't handle type changes
426
 
        self.assertRaises(AssertionError, import_version, 'output3',
427
 
                          pybaz.Version(self._baz._import_symlink))
 
454
        # Test kind change for import
 
455
        import_version('output3', pybaz.Version(self._baz._import_symlink),
 
456
                       None)
428
457
 
429
458
    def test_missing_ancestor(self):
430
 
        import_version('output', pybaz.Version(self._baz._missing_ancestor))
 
459
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
 
460
                       None)
431
461
        # expected results:
432
 
        # one commits, no files, revision identifiers of 
 
462
        # one commits, no files, revision identifiers of
433
463
        # 'demo@DONOTUSE_c--gone--0--base-0' and
434
464
        # a merge of demo-gone@DONOTUSE%c--import--0
435
465
        branch = Branch.open('output')
437
467
                         [self._baz._missing_ancestor_bzr])
438
468
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
439
469
        # and again.
440
 
        import_version('output2', pybaz.Version(self._baz._missing_ancestor))
 
470
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
 
471
                       None)
441
472
        branch2 = Branch.open('output2')
442
473
        self.assertEqual(branch.revision_history(), branch2.revision_history())
443
474
        rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)
446
477
 
447
478
        # and we should get some expected values:
448
479
        self.assertEqual(rev.committer, "Test User<test@example.org>")
449
 
        self.assertEqual(rev.message, 
 
480
        self.assertEqual(rev.message,
450
481
                         "tag of demo-gone@DONOTUSE/c--import--0--base-0")
451
482
        self.assertEqual(rev.revision_id, self._baz._missing_ancestor_bzr)
452
483
        self.assertEqual(rev.parent_ids[0], self._baz._missing_import_bzr)
453
484
        self.assertEqual(1, len(rev.parent_ids))
454
485
 
455
486
        # must NOT be able to get the merged evision
456
 
        self.assertRaises(NoSuchRevision, branch.repository.get_revision, 
 
487
        self.assertRaises(NoSuchRevision, branch.repository.get_revision,
457
488
                          self._baz._missing_import_bzr)
458
489
 
459
490
    def test_missing_ancestor_reusing_history(self):
460
491
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
 
492
                       None,
461
493
                       reuse_history_from=[self._baz._missing_import_imported])
462
494
        # expected results:
463
 
        # one commits, no files, revision identifiers of 
464
 
        # 'demo-gone@DONOTUSE%c--import--0--base-0' and 
 
495
        # one commits, no files, revision identifiers of
 
496
        # 'demo-gone@DONOTUSE%c--import--0--base-0' and
465
497
        # 'demo@DONOTUSE%c--gone--0--base-0'
466
498
        branch = Branch.open('output')
467
499
        self.assertEqual(branch.revision_history(),
470
502
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
471
503
        # and again.
472
504
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
 
505
                       None,
473
506
                       reuse_history_from=[self._baz._missing_import_imported])
474
507
        branch2 = Branch.open('output2')
475
508
        self.assertEqual(branch.revision_history(), branch2.revision_history())
482
515
 
483
516
        # and we should get some expected values:
484
517
        self.assertEqual(rev.committer, "Test User<test@example.org>")
485
 
        self.assertEqual(rev.message, 
 
518
        self.assertEqual(rev.message,
486
519
                         "tag of demo-gone@DONOTUSE/c--import--0--base-0")
487
520
        self.assertEqual(rev.revision_id, self._baz._missing_ancestor_bzr)
488
521
        self.assertEqual(rev.parent_ids[0], self._baz._missing_import_bzr)
489
522
        self.assertEqual(1, len(rev.parent_ids))
490
523
 
491
524
    def test_bad_file_id(self):
492
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag))
 
525
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
493
526
        # expected results:
494
 
        # three commits, one files, revision identifiers of 
 
527
        # three commits, one files, revision identifiers of
495
528
        # 'demo@DONOTUSE_c--import--0--base-0' ,
496
529
        # 'demo@DONOTUSE/c--bad-id--0--base-0' ,
497
530
        # ''demo@DONOTUSE/c--bad-id--0--patch-1'
506
539
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
507
540
 
508
541
    def test_appending_revisions_already_present(self):
509
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
 
542
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None,
510
543
                       max_count=2)
511
544
        # expected results:
512
 
        # three commits, one files, revision identifiers of 
 
545
        # three commits, one files, revision identifiers of
513
546
        # 'demo@DONOTUSE_c--import--0--base-0' ,
514
547
        # 'demo@DONOTUSE/c--bad-id--0--base-0' ,
515
548
        # ''demo@DONOTUSE/c--bad-id--0--patch-1'
524
557
        self.assertEqual(branch.revision_history(),
525
558
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
526
559
        del branch
527
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag))
 
560
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
528
561
        branch = Branch.open('output')
529
562
        self.assertEqual(branch.revision_history(),
530
563
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
536
569
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
537
570
 
538
571
    def test_appending_revisions_all_already_present(self):
539
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag))
 
572
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
540
573
        # expected results:
541
 
        # three commits, one files, revision identifiers of 
 
574
        # three commits, one files, revision identifiers of
542
575
        # 'demo@DONOTUSE_c--import--0--base-0' ,
543
576
        # 'demo@DONOTUSE/c--bad-id--0--base-0' ,
544
577
        # ''demo@DONOTUSE/c--bad-id--0--patch-1'
554
587
        self.assertEqual(branch.revision_history(),
555
588
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
556
589
        del branch
557
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag))
 
590
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
558
591
        branch = Branch.open('output')
559
592
        self.assertEqual(branch.revision_history(),
560
593
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
566
599
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
567
600
 
568
601
    def test_inbranch_conversion(self):
569
 
        import_version('output', pybaz.Version(self._baz._inbranch_tag))
 
602
        import_version('output', pybaz.Version(self._baz._inbranch_tag), None)
570
603
        # expected results:
571
 
        # three commits, no files, revision identifiers of 
 
604
        # three commits, no files, revision identifiers of
572
605
        # 'demo@DONOTUSE_c--import--0--base-0' and
573
606
        # self._baz._inbranch_tag_base_bzr
574
607
        # self._baz._inbranch_tag_head_bzr
579
612
                          self._baz._inbranch_tag_base_bzr,
580
613
                          self._baz._inbranch_tag_head_bzr])
581
614
        # and again.
582
 
        import_version('output2', pybaz.Version(self._baz._inbranch_tag))
 
615
        import_version('output2', pybaz.Version(self._baz._inbranch_tag), None)
583
616
        branch2 = Branch.open('output2')
584
 
        
 
617
 
585
618
        self.assertEqual(branch.revision_history(), branch2.revision_history())
586
619
        # check revisions in the history.
587
620
        rev = branch.repository.get_revision(self._baz._inbranch_tag_base_bzr)
609
642
        path = 'output'
610
643
        os.mkdir(path)
611
644
        branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(path)
612
 
        import_version(path, pybaz.Version(self._baz._import))
 
645
        import_version(path, pybaz.Version(self._baz._import), None)
613
646
        # expected results:
614
 
        # one commit, revision identifier of 
 
647
        # one commit, revision identifier of
615
648
        # 'demo@DONOTUSE_c--import--0--base-0'
616
649
        self.assertEqual(branch.revision_history(),
617
650
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
629
662
    def test_patch1_base0(self):
630
663
        self.assertEqual(namespace_previous(self.version['patch-1']),
631
664
                         self.version['base-0'])
632
 
        
 
665
 
633
666
    def test_patch3000_patch2999(self):
634
667
        self.assertEqual(namespace_previous(self.version['patch-3000']),
635
668
                         self.version['patch-2999'])
636
 
        
 
669
 
637
670
    def test_version0_raises(self):
638
671
        self.assertRaises(RuntimeError, namespace_previous,
639
672
                          self.version['version-0'])
660
693
        from bzrlib.plugins.bzrtools.baz_import import map_namespace
661
694
        category = pybaz.Category('foo@example.com/c')
662
695
        self.assertRaises(pybaz.errors.NamespaceError, map_namespace, category)
663
 
        self.assertEqual('c/+trunk', 
 
696
        self.assertEqual('c/+trunk',
664
697
                         map_namespace(pybaz.Version("%s--0" % category)))
665
698
        self.assertEqual('c/0.1/+trunk',
666
699
                         map_namespace(pybaz.Version('%s--0.1' % category)))
693
726
    def make_import(self, namespace):
694
727
        self._import = 'demo@DONOTUSE/%s' % namespace
695
728
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
696
 
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
729
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
697
730
                               self._import)
698
731
        msg = tree.log_message()
699
732
        msg["summary"] = "I am importing now"
701
734
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
702
735
 
703
736
    def test_cmd_exists(self):
704
 
        from bzrlib.plugins.bzrtools.baz_import import cmd_baz_import
 
737
        from bzrlib.plugins.bzrtools import cmd_baz_import
705
738
 
706
739
    def test_empty_archive(self):
707
740
        command = cmd_baz_import()
708
741
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
709
742
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output')))
710
743
        walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))
711
 
        self.assertEqual(7, walk_len)
 
744
        self.assertEqual(9, walk_len)
712
745
 
713
746
    def test_two_branches(self):
714
747
        self.make_import('c--0')
716
749
        command = cmd_baz_import()
717
750
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
718
751
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output')))
719
 
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 
 
752
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output',
720
753
                                       'c','+trunk')))
721
 
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 
 
754
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output',
722
755
                                                    'c1', '0.2','branch')))
 
756
        default_format = repository.RepositoryFormat.get_default_format()
723
757
        walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))
724
 
        self.assertEqual(20, walk_len)
 
758
        self.assertEqual(22, walk_len)
725
759
 
726
760
    def test_run_twice(self):
727
761
        self.make_import('c--0')
728
762
        command = cmd_baz_import()
729
763
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
730
764
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
731
 
        
 
765
 
732
766
    def test_accepts_reuse_history(self):
733
767
        self.make_import('c--0')
734
 
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),
735
 
                     'demo@DONOTUSE', '.', '.')
736
 
        
737
 
    def test_does_not_need_reuse_history(self):
738
 
        self.make_import('c--0')
739
 
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),
740
 
                     'demo@DONOTUSE')
741
 
 
 
768
        self.run_bzr(['baz-import', os.path.join(self._tmpdir, 'output'),
 
769
                      'demo@DONOTUSE', '.', '.'])
 
770
 
 
771
    def test_does_not_need_reuse_history(self):
 
772
        self.make_import('c--0')
 
773
        self.run_bzr(['baz-import', os.path.join(self._tmpdir, 'output'),
 
774
                      'demo@DONOTUSE'])
 
775
 
 
776
    def test_does_not_need_reuse_history(self):
 
777
        self.make_import('c--0')
 
778
        self.run_bzr(['baz-import', os.path.join(self._tmpdir, 'output'),
 
779
                      'demo@DONOTUSE'])
 
780
 
 
781
    def test_encoding_flag(self):
 
782
        self.make_import('c--0')
 
783
        self.run_bzr(['baz-import', os.path.join(self._tmpdir, 'output'),
 
784
                      'demo@DONOTUSE'])
 
785
        self.assertEqual(['Arch-1:demo@DONOTUSE%c--0--base-0'],
 
786
                         Branch.open(os.path.join(self._tmpdir,
 
787
                                     'output/c/+trunk')).revision_history())
 
788
        self.run_bzr(['baz-import', os.path.join(self._tmpdir, 'output2'),
 
789
                      'demo@DONOTUSE', '--encoding', 'utf-8'])
 
790
        self.assertEqual(['Arch-1-utf-8:demo@DONOTUSE%c--0--base-0'],
 
791
                         Branch.open(os.path.join(self._tmpdir,
 
792
                                     'output2/c/+trunk')).revision_history())
 
793
        self.run_bzr(['baz-import-branch', os.path.join(self._tmpdir,
 
794
                      'output3'), 'demo@DONOTUSE/c--0'])
 
795
        self.assertEqual(['Arch-1:demo@DONOTUSE%c--0--base-0'],
 
796
                         Branch.open(os.path.join(self._tmpdir,
 
797
                                     'output3')).revision_history())
 
798
        self.run_bzr(['baz-import-branch', os.path.join(self._tmpdir,
 
799
                      'output4'), 'demo@DONOTUSE/c--0', '--encoding', 'utf-8'])
 
800
        self.assertEqual(['Arch-1-utf-8:demo@DONOTUSE%c--0--base-0'],
 
801
                         Branch.open(os.path.join(self._tmpdir,
 
802
                                     'output4')).revision_history())