← 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-05-12 03:22:55 UTC
  • mfrom: (0.9.28 heads)
  • Revision ID: aaron@aaronbentley.com-20080512032255-gevqj6eos15kob0j
Merge in heads command

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_baz_import.py
16
16
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
18
from bzrlib.tests import TestCaseInTempDir, TestCase
 
19
from bzrlib import repository
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
 
from bzrlib.plugins.bzrtools.baz_import import (import_version, revision_id, 
26
 
                                                cmd_baz_import, make_archive)
27
 
from bzrlib.errors import NoSuchRevision
 
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)
28
31
import shutil
29
32
from StringIO import StringIO
30
33
import tempfile
31
34
from testresources import (TestResource, TestLoader, OptimisingTestSuite,
32
35
                               ResourcedTestCase)
33
 
    
 
36
 
 
37
import bzrlib
 
38
from bzrlib.errors import NoSuchRevision
34
39
from bzrlib.plugins.bzrtools.fai import namespace_previous
35
40
from bzrlib.branch import Branch
36
41
 
39
44
        from unittest import TestSuite
40
45
        return TestSuite()
41
46
    return TestLoader().loadTestsFromName(__name__)
42
 
 
 
47
 
43
48
 
44
49
class BazTreeResource(TestResource):
45
50
 
59
64
        pybaz.set_my_id("Test User<test@example.org>")
60
65
 
61
66
        self.make_empty_import()
 
67
        self.make_utf8_log()
62
68
 
63
69
        self._empty_tag = 'demo@DONOTUSE/c--empty-tag--0'
64
 
        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0')
 
70
        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0', None)
65
71
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
66
72
            pybaz.Version(self._empty_tag))
67
73
 
68
74
        self._empty_merged_tag = 'demo@DONOTUSE/c--empty-merged-tag--0'
69
 
        self._empty_merged_tag_bzr_base = revision_id(self._empty_merged_tag 
70
 
                                                 + '--base-0')
71
 
        self._empty_merged_tag_bzr = revision_id(self._empty_merged_tag 
72
 
                                                 + '--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)
73
79
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
74
80
            pybaz.Version(self._empty_merged_tag))
75
81
        tree = pybaz.Revision(self._empty_merged_tag + '--base-0').get(
80
86
        msg["summary"]="did a merge, yarh"
81
87
        tree.commit(msg)
82
88
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
83
 
        
 
89
 
84
90
        # tree, two commits, includes merge of other branch
85
91
        self._empty_merged_tag_2 = 'demo@DONOTUSE/c--empty-tag-2--0'
86
92
        self._empty_merged_tag_2_bzr_base = revision_id(
87
 
            self._empty_merged_tag_2 + '--base-0')
 
93
            self._empty_merged_tag_2 + '--base-0', None)
88
94
        self._empty_merged_tag_2_bzr = revision_id(
89
 
            self._empty_merged_tag_2 + '--patch-1')
 
95
            self._empty_merged_tag_2 + '--patch-1', None)
90
96
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
91
97
            pybaz.Version(self._empty_merged_tag_2))
92
98
        tree = pybaz.Revision(self._empty_merged_tag_2 + '--base-0').get (
99
105
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
100
106
 
101
107
        self._bad_id_tag = 'demo@DONOTUSE/c--bad-id--0'
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')
 
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)
104
112
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
105
113
            pybaz.Version(self._bad_id_tag))
106
114
        tree = pybaz.Revision(self._bad_id_tag + '--base-0').get(
107
115
            os.path.join(self._tmpdir, 'tree'))
108
116
        from bzrlib.plugins.bzrtools.baz_import import add_file
109
 
        add_file(os.path.join(self._tmpdir,'tree/path'), 'text', 
 
117
        add_file(os.path.join(self._tmpdir,'tree/path'), 'text',
110
118
                 'this_id/needs%escaping')
111
119
        msg = tree.log_message()
112
120
        msg["summary"] = "commit something which needs escaping."
120
128
    def make_import_symlink(self):
121
129
        self._import_symlink = 'demo@DONOTUSE/c--import-symlink--0'
122
130
        self._import_symlink_bzr = revision_id(
123
 
            self._import_symlink + '--base-0')
 
131
            self._import_symlink + '--base-0', None)
124
132
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
125
133
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
126
134
                               self._import_symlink)
127
 
        os.symlink('missing-file-name',
128
 
                   os.path.join(self._tmpdir, 'tree', 'alink'))
 
135
        link_path = os.path.join(self._tmpdir, 'tree', 'alink')
 
136
        os.symlink('missing-file-name', link_path)
129
137
        tree.add_tag('alink')
130
138
        id_file = open(os.path.join(tree, '.arch-ids', 'alink.id'), 'w')
131
139
        id_file.write('symlink_tag\n')
133
141
        msg = tree.log_message()
134
142
        msg["summary"] = "Import with a symlink"
135
143
        tree.import_(msg)
 
144
        os.unlink(link_path)
 
145
        f = file(link_path, 'w')
 
146
        f.write('Not a symlink no more!')
 
147
        f.close()
 
148
        msg = tree.log_message()
 
149
        msg["summary"] = "Turn a symlink into a file"
 
150
        tree.commit(msg)
136
151
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
137
152
 
138
153
    def make_empty_import(self):
139
154
        self._import = 'demo@DONOTUSE/c--import--0'
140
155
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
141
 
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
156
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
142
157
                               self._import)
143
158
        msg = tree.log_message()
144
159
        msg["summary"] = "I am importing now"
145
160
        tree.import_(msg)
146
161
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
147
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
 
148
173
    def make_missing_ancestor(self):
149
174
        self._archivegoneroot = os.path.join(self._tmpdir, 'archivegone')
150
175
        self._archive = make_archive('demo-gone@DONOTUSE',
151
176
                                     str(self._archivegoneroot))
152
177
        self._missing_import = 'demo-gone@DONOTUSE/c--import--0'
153
 
        self._missing_import_bzr = revision_id(self._missing_import 
154
 
                                                 + '--base-0')
 
178
        self._missing_import_bzr = revision_id(self._missing_import
 
179
                                                 + '--base-0', None)
155
180
        self._missing_ancestor = 'demo@DONOTUSE/c--gone--0'
156
 
        self._missing_ancestor_bzr = revision_id(self._missing_ancestor 
157
 
                                                 + '--base-0')
 
181
        self._missing_ancestor_bzr = revision_id(self._missing_ancestor
 
182
                                                 + '--base-0', None)
158
183
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
159
 
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
184
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
160
185
                               self._missing_import)
161
186
        msg = tree.log_message()
162
187
        msg["summary"] = "I am importing now"
167
192
            pybaz.Version(self._missing_ancestor))
168
193
 
169
194
        # make an import for testing history-reuse logic.
170
 
        def collect(text):
171
 
            pass
172
195
        # note the use of a namespace layout here.
173
 
        self._missing_import_imported = os.path.join(self._tmpdir, 
 
196
        self._missing_import_imported = os.path.join(self._tmpdir,
174
197
                                                     'archivegone-bzr')
175
198
        os.mkdir(os.path.join(self._tmpdir, 'archivegone-bzr'))
176
199
        os.mkdir(os.path.join(self._tmpdir, 'archivegone-bzr', 'c'))
177
 
        import_version(os.path.join(self._tmpdir, 'archivegone-bzr', 
 
200
        import_version(os.path.join(self._tmpdir, 'archivegone-bzr',
178
201
                                    'c', 'import'),
179
 
                       pybaz.Version(self._missing_import),
180
 
                       collect)
 
202
                       pybaz.Version(self._missing_import), None)
181
203
        # and make it inaccessible
182
204
        pybaz.Archive('demo-gone@DONOTUSE').unregister()
183
205
 
184
206
    def make_inbranch_continuation(self):
185
207
        self._inbranch_tag = 'demo@DONOTUSE/c--inbranch-tag--0'
186
208
        self._inbranch_tag_base = self._inbranch_tag + '--base-0'
187
 
        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)
188
211
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
189
212
            pybaz.Version(self._inbranch_tag))
190
213
        self._inbranch_tag_head = self._inbranch_tag + '--patch-1'
191
 
        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)
192
216
        pybaz.Revision(self._inbranch_tag_base).make_continuation(
193
217
            pybaz.Version(self._inbranch_tag))
194
218
 
209
233
        TestCaseInTempDir.setUp(self)
210
234
        ResourcedTestCase.setUpResources(self)
211
235
        os.environ['HOME'] = self._baz._homedir
212
 
        self.output = StringIO()
213
236
 
214
237
    def tearDown(self):
215
238
        ResourcedTestCase.tearDownResources(self)
216
239
        TestCaseInTempDir.tearDown(self)
217
 
 
218
 
    def collect(self, text):
219
 
        self.output.write(text)
220
 
        self.output.write("\n")
221
 
 
 
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
 
222
255
    def test_import_empty(self):
223
 
        import_version('output', pybaz.Version(self._baz._import), 
224
 
                       self.collect)
 
256
        import_version('output', pybaz.Version(self._baz._import), None)
225
257
        # expected results:
226
 
        # one commit, no files, revision identifier of 
 
258
        # one commit, no files, revision identifier of
227
259
        # 'demo@DONOTUSE_c--import--0--base-0'
228
260
        branch = Branch.open('output')
229
261
        repo = branch.repository
232
264
        rev = repo.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
233
265
        # and again.
234
266
        import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'),
235
 
                       self.collect)
 
267
                       None)
236
268
        branch2 = Branch.open('output2')
237
269
        repo2 = branch2.repository
238
270
        self.assertEqual(branch.revision_history(), branch2.revision_history())
247
279
                         "Arch-1:demo@DONOTUSE%c--import--0--base-0")
248
280
 
249
281
    def test_empty_tagged(self):
250
 
        import_version('output', pybaz.Version(self._baz._empty_tag),
251
 
                       self.collect)
 
282
        import_version('output', pybaz.Version(self._baz._empty_tag), None)
252
283
        # expected results:
253
 
        # two commits, no files, revision identifiers of 
 
284
        # two commits, no files, revision identifiers of
254
285
        # 'demo@DONOTUSE_c--import--0--base-0' and
255
286
        # self._baz._empty_tag_bzr
256
287
        branch = Branch.open('output')
259
290
                          self._baz._empty_tag_bzr])
260
291
        rev = branch.repository.get_revision(self._baz._empty_tag_bzr)
261
292
        # and again.
262
 
        import_version('output2', pybaz.Version(self._baz._empty_tag),
263
 
                       self.collect)
 
293
        import_version('output2', pybaz.Version(self._baz._empty_tag), None)
264
294
        branch2 = Branch.open('output2')
265
295
        self.assertEqual(branch.revision_history(), branch2.revision_history())
266
296
        rev2 = branch2.repository.get_revision(self._baz._empty_tag_bzr)
269
299
 
270
300
        # and we should get some expected values:
271
301
        self.assertEqual(rev.committer, "Test User<test@example.org>")
272
 
        self.assertEqual(rev.message, 
 
302
        self.assertEqual(rev.message,
273
303
                         "tag of demo@DONOTUSE/c--import--0--base-0")
274
304
        self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)
275
305
 
276
306
    def test_empty_merged_tagged(self):
277
307
        import_version('output', pybaz.Version(self._baz._empty_merged_tag),
278
 
                       self.collect)
 
308
                       None)
279
309
        # expected results:
280
 
        # two commits, no files, revision identifiers of 
 
310
        # two commits, no files, revision identifiers of
281
311
        # 'demo@DONOTUSE_c--import--0--base-0' and
282
312
        # self._baz._empty_merged_tag_bzr_base
283
313
        # self._baz._empty_merged_tag_bzr
291
321
                          self._baz._empty_merged_tag_bzr])
292
322
        # and again.
293
323
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag),
294
 
                       self.collect)
 
324
                       None)
295
325
        branch2 = Branch.open('output2')
296
326
        repo2 = branch2.repository
297
327
        # and import what we should be merged up against for checking with.
298
 
        import_version('output3', pybaz.Version(self._baz._empty_tag),
299
 
                       self.collect)
 
328
        import_version('output3', pybaz.Version(self._baz._empty_tag), None)
300
329
        branch3 = Branch.open('output3')
301
 
        
 
330
 
302
331
        self.assertEqual(branch.revision_history(), branch2.revision_history())
303
 
        self.assertNotEqual(branch.revision_history(), 
 
332
        self.assertNotEqual(branch.revision_history(),
304
333
                            branch3.revision_history())
305
334
        # check revisions in the history.
306
335
        rev = repo.get_revision(self._baz._empty_merged_tag_bzr_base)
309
338
        self.assertEqual(rev, rev2)
310
339
        # and we should get some expected values:
311
340
        self.assertEqual(rev.committer, "Test User<test@example.org>")
312
 
        self.assertEqual(rev.message, 
 
341
        self.assertEqual(rev.message,
313
342
                         "tag of demo@DONOTUSE/c--import--0--base-0")
314
343
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr_base)
315
344
        self.assertEqual(['Arch-1:demo@DONOTUSE%c--import--0--base-0'],
328
357
                         self._baz._empty_merged_tag_bzr_base)
329
358
        self.assertEqual(rev.parent_ids[1], self._baz._empty_tag_bzr)
330
359
 
331
 
        # this tree should have nothing missing from that tree.   
 
360
        # this tree should have nothing missing from that tree.
332
361
        # FIXME there is no code for this right now.
333
362
        # self.assertEqual(branch.missing_revisions(branch3), [])
334
 
        
 
363
 
335
364
    def test_merge_branch_with_merges(self):
336
365
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2),
337
 
                       self.collect)
 
366
                       None)
338
367
        # expected results:
339
 
        # two commits, no files, revision identifiers of 
 
368
        # two commits, no files, revision identifiers of
340
369
        # 'demo@DONOTUSE_c--import--0--base-0' and
341
370
        # self._baz._empty_merged_tag_2_bzr_base
342
371
        # self._baz._empty_merged_tag_2_bzr
350
379
                          self._baz._empty_merged_tag_2_bzr])
351
380
        # and again.
352
381
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2),
353
 
                       self.collect)
 
382
                       None)
354
383
        branch2 = Branch.open('output2')
355
384
        repo2 = branch2.repository
356
385
        # and import what we should be merged up against for checking with.
357
386
        import_version('output3', pybaz.Version(self._baz._empty_merged_tag),
358
 
                       self.collect)
 
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
424
        import_version('output', pybaz.Version(self._baz._import_symlink),
396
 
                       self.collect)
 
425
                       None, max_count=1)
397
426
        # expected results:
398
 
        # one commit, 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
 
                       self.collect)
 
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
 
 
454
        # Test kind change for import
 
455
        import_version('output3', pybaz.Version(self._baz._import_symlink),
 
456
                       None)
 
457
 
425
458
    def test_missing_ancestor(self):
426
459
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
427
 
                       self.collect)
 
460
                       None)
428
461
        # expected results:
429
 
        # one commits, no files, revision identifiers of 
 
462
        # one commits, no files, revision identifiers of
430
463
        # 'demo@DONOTUSE_c--gone--0--base-0' and
431
464
        # a merge of demo-gone@DONOTUSE%c--import--0
432
465
        branch = Branch.open('output')
435
468
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
436
469
        # and again.
437
470
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
438
 
                       self.collect)
 
471
                       None)
439
472
        branch2 = Branch.open('output2')
440
473
        self.assertEqual(branch.revision_history(), branch2.revision_history())
441
474
        rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)
444
477
 
445
478
        # and we should get some expected values:
446
479
        self.assertEqual(rev.committer, "Test User<test@example.org>")
447
 
        self.assertEqual(rev.message, 
 
480
        self.assertEqual(rev.message,
448
481
                         "tag of demo-gone@DONOTUSE/c--import--0--base-0")
449
482
        self.assertEqual(rev.revision_id, self._baz._missing_ancestor_bzr)
450
483
        self.assertEqual(rev.parent_ids[0], self._baz._missing_import_bzr)
451
484
        self.assertEqual(1, len(rev.parent_ids))
452
485
 
453
486
        # must NOT be able to get the merged evision
454
 
        self.assertRaises(NoSuchRevision, branch.repository.get_revision, 
 
487
        self.assertRaises(NoSuchRevision, branch.repository.get_revision,
455
488
                          self._baz._missing_import_bzr)
456
489
 
457
490
    def test_missing_ancestor_reusing_history(self):
458
491
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
459
 
                       self.collect,
 
492
                       None,
460
493
                       reuse_history_from=[self._baz._missing_import_imported])
461
494
        # expected results:
462
 
        # one commits, no files, revision identifiers of 
463
 
        # '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
464
497
        # 'demo@DONOTUSE%c--gone--0--base-0'
465
498
        branch = Branch.open('output')
466
499
        self.assertEqual(branch.revision_history(),
469
502
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
470
503
        # and again.
471
504
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
472
 
                       self.collect,
 
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),
493
 
                       self.collect)
 
525
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
494
526
        # expected results:
495
 
        # three commits, one files, revision identifiers of 
 
527
        # three commits, one files, revision identifiers of
496
528
        # 'demo@DONOTUSE_c--import--0--base-0' ,
497
529
        # 'demo@DONOTUSE/c--bad-id--0--base-0' ,
498
530
        # ''demo@DONOTUSE/c--bad-id--0--patch-1'
507
539
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
508
540
 
509
541
    def test_appending_revisions_already_present(self):
510
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
511
 
                       self.collect, max_count=2)
 
542
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None,
 
543
                       max_count=2)
512
544
        # expected results:
513
 
        # three commits, one files, revision identifiers of 
 
545
        # three commits, one files, revision identifiers of
514
546
        # 'demo@DONOTUSE_c--import--0--base-0' ,
515
547
        # 'demo@DONOTUSE/c--bad-id--0--base-0' ,
516
548
        # ''demo@DONOTUSE/c--bad-id--0--patch-1'
525
557
        self.assertEqual(branch.revision_history(),
526
558
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
527
559
        del branch
528
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
529
 
                       self.collect)
 
560
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
530
561
        branch = Branch.open('output')
531
562
        self.assertEqual(branch.revision_history(),
532
563
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
538
569
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
539
570
 
540
571
    def test_appending_revisions_all_already_present(self):
541
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
542
 
                       self.collect)
 
572
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
543
573
        # expected results:
544
 
        # three commits, one files, revision identifiers of 
 
574
        # three commits, one files, revision identifiers of
545
575
        # 'demo@DONOTUSE_c--import--0--base-0' ,
546
576
        # 'demo@DONOTUSE/c--bad-id--0--base-0' ,
547
577
        # ''demo@DONOTUSE/c--bad-id--0--patch-1'
557
587
        self.assertEqual(branch.revision_history(),
558
588
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
559
589
        del branch
560
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
561
 
                       self.collect)
 
590
        import_version('output', pybaz.Version(self._baz._bad_id_tag), None)
562
591
        branch = Branch.open('output')
563
592
        self.assertEqual(branch.revision_history(),
564
593
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
570
599
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
571
600
 
572
601
    def test_inbranch_conversion(self):
573
 
        import_version('output', pybaz.Version(self._baz._inbranch_tag),
574
 
                       self.collect)
 
602
        import_version('output', pybaz.Version(self._baz._inbranch_tag), None)
575
603
        # expected results:
576
 
        # three commits, no files, revision identifiers of 
 
604
        # three commits, no files, revision identifiers of
577
605
        # 'demo@DONOTUSE_c--import--0--base-0' and
578
606
        # self._baz._inbranch_tag_base_bzr
579
607
        # self._baz._inbranch_tag_head_bzr
584
612
                          self._baz._inbranch_tag_base_bzr,
585
613
                          self._baz._inbranch_tag_head_bzr])
586
614
        # and again.
587
 
        import_version('output2', pybaz.Version(self._baz._inbranch_tag),
588
 
                       self.collect)
 
615
        import_version('output2', pybaz.Version(self._baz._inbranch_tag), None)
589
616
        branch2 = Branch.open('output2')
590
 
        
 
617
 
591
618
        self.assertEqual(branch.revision_history(), branch2.revision_history())
592
619
        # check revisions in the history.
593
620
        rev = branch.repository.get_revision(self._baz._inbranch_tag_base_bzr)
611
638
        self.assertEqual(rev.parent_ids,
612
639
                         [self._baz._inbranch_tag_base_bzr])
613
640
 
 
641
    def test_no_commits_same_as_missing(self):
 
642
        path = 'output'
 
643
        os.mkdir(path)
 
644
        branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(path)
 
645
        import_version(path, pybaz.Version(self._baz._import), None)
 
646
        # expected results:
 
647
        # one commit, revision identifier of
 
648
        # 'demo@DONOTUSE_c--import--0--base-0'
 
649
        self.assertEqual(branch.revision_history(),
 
650
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
 
651
 
614
652
 
615
653
class TestNamespacePrevious(TestCase):
616
654
 
624
662
    def test_patch1_base0(self):
625
663
        self.assertEqual(namespace_previous(self.version['patch-1']),
626
664
                         self.version['base-0'])
627
 
        
 
665
 
628
666
    def test_patch3000_patch2999(self):
629
667
        self.assertEqual(namespace_previous(self.version['patch-3000']),
630
668
                         self.version['patch-2999'])
631
 
        
 
669
 
632
670
    def test_version0_raises(self):
633
671
        self.assertRaises(RuntimeError, namespace_previous,
634
672
                          self.version['version-0'])
641
679
        self.assertEqual(namespace_previous(self.version['versionfix-3000']),
642
680
                         self.version['versionfix-2999'])
643
681
 
 
682
 
644
683
class TestNamespaceMapping(TestCase):
645
684
 
646
685
    def test_namespace_mapping_branch(self):
654
693
        from bzrlib.plugins.bzrtools.baz_import import map_namespace
655
694
        category = pybaz.Category('foo@example.com/c')
656
695
        self.assertRaises(pybaz.errors.NamespaceError, map_namespace, category)
657
 
        self.assertEqual('c/+trunk', 
 
696
        self.assertEqual('c/+trunk',
658
697
                         map_namespace(pybaz.Version("%s--0" % category)))
659
698
        self.assertEqual('c/0.1/+trunk',
660
699
                         map_namespace(pybaz.Version('%s--0.1' % category)))
663
702
class TestFileIdMapping(TestCase):
664
703
 
665
704
    def test_slash(self):
666
 
        from bzrlib.plugins.bzrtools.baz_import import map_file_id
667
705
        self.assertEqual('c%2fc', map_file_id('c/c'))
668
706
        self.assertEqual('c%25c', map_file_id('c%c'))
669
707
 
688
726
    def make_import(self, namespace):
689
727
        self._import = 'demo@DONOTUSE/%s' % namespace
690
728
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
691
 
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
729
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
692
730
                               self._import)
693
731
        msg = tree.log_message()
694
732
        msg["summary"] = "I am importing now"
696
734
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
697
735
 
698
736
    def test_cmd_exists(self):
699
 
        from bzrlib.plugins.bzrtools.baz_import import cmd_baz_import
 
737
        from bzrlib.plugins.bzrtools import cmd_baz_import
700
738
 
701
739
    def test_empty_archive(self):
702
740
        command = cmd_baz_import()
703
741
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
704
742
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output')))
705
743
        walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))
706
 
        self.assertEqual(7, walk_len)
 
744
        self.assertEqual(9, walk_len)
707
745
 
708
746
    def test_two_branches(self):
709
747
        self.make_import('c--0')
711
749
        command = cmd_baz_import()
712
750
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
713
751
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output')))
714
 
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 
 
752
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output',
715
753
                                       'c','+trunk')))
716
 
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 
 
754
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output',
717
755
                                                    'c1', '0.2','branch')))
 
756
        default_format = repository.RepositoryFormat.get_default_format()
718
757
        walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))
719
758
        self.assertEqual(22, walk_len)
720
759
 
723
762
        command = cmd_baz_import()
724
763
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
725
764
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
726
 
        
 
765
 
727
766
    def test_accepts_reuse_history(self):
728
767
        self.make_import('c--0')
729
 
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),
730
 
                     'demo@DONOTUSE', '.', '.')
731
 
        
732
 
    def test_does_not_need_reuse_history(self):
733
 
        self.make_import('c--0')
734
 
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),
735
 
                     'demo@DONOTUSE')
 
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())