← 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-06-18 01:39:32 UTC
  • Revision ID: aaron.bentley@utoronto.ca-20060618013932-0162fdb3edab394b
Update is_clean test, now that commit returns a revision_id

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