← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to tests/test_baz_import.py

  • Committer: Aaron Bentley
  • Date: 2007-06-12 15:52:05 UTC
  • mfrom: (535.1.1 bzrtools)
  • Revision ID: abentley@panoramicfeedback.com-20070612155205-ssbl678bfz266ptb
Merge fix for symlinks in directories

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