← 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 04:14:21 UTC
  • Revision ID: aaron@aaronbentley.com-20080512041421-hunspdyev3rxqx7u
Avoid using deprecated interface for heads

Show diffs side-by-side

added added

removed removed

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