~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to tests/test_baz_import.py

  • Committer: Aaron Bentley
  • Date: 2006-07-11 18:56:01 UTC
  • Revision ID: abentley@panoramicfeedback.com-20060711185601-6e7f164148ed616d
Remove <BZRTOOLS> tag from command descriptions

Show diffs side-by-side

added added

removed removed

Lines of Context:
15
15
#    along with this program; if not, write to the Free Software
16
16
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
 
from bzrlib.selftest import TestCaseInTempDir, TestCase
19
 
from bzrlib.selftest.blackbox import has_symlinks
 
18
from bzrlib.tests import TestCaseInTempDir, TestCase
 
19
from bzrlib.osutils import has_symlinks
20
20
try:
21
21
    import pybaz
22
22
except ImportError:
23
23
    pybaz = None
24
24
import os
25
 
from bzrlib.plugins.bzrtools.baz_import import (import_version, revision_id, 
26
 
                                                cmd_baz_import)
27
 
from bzrlib.errors import NoSuchRevision
 
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)
28
34
import shutil
29
35
from StringIO import StringIO
30
36
import tempfile
31
37
from testresources import (TestResource, TestLoader, OptimisingTestSuite,
32
 
                           ResourcedTestCase)
33
 
from bzrlib.plugins.bzrtools.fai import namespace_previous
 
38
                               ResourcedTestCase)
 
39
    
 
40
import bzrlib
 
41
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
34
46
from bzrlib.branch import Branch
35
47
 
36
48
def test_suite():
37
49
    if pybaz is None:
38
 
        return OptimisingTestSuite()
 
50
        from unittest import TestSuite
 
51
        return TestSuite()
39
52
    return TestLoader().loadTestsFromName(__name__)
40
53
 
41
54
 
53
66
        os.environ['HOME'] = self._homedir
54
67
 
55
68
        self._archiveroot = os.path.join(self._tmpdir, 'archive')
56
 
        self._archive = pybaz.make_archive('demo@DONOTUSE', str(self._archiveroot))
 
69
        self._archive = make_archive('demo@DONOTUSE', str(self._archiveroot))
57
70
        pybaz.set_my_id("Test User<test@example.org>")
58
71
 
59
72
        self.make_empty_import()
81
94
        
82
95
        # tree, two commits, includes merge of other branch
83
96
        self._empty_merged_tag_2 = 'demo@DONOTUSE/c--empty-tag-2--0'
84
 
        self._empty_merged_tag_2_bzr_base = revision_id(self._empty_merged_tag_2 + '--base-0')
85
 
        self._empty_merged_tag_2_bzr = revision_id(self._empty_merged_tag_2 + '--patch-1')
 
97
        self._empty_merged_tag_2_bzr_base = revision_id(
 
98
            self._empty_merged_tag_2 + '--base-0')
 
99
        self._empty_merged_tag_2_bzr = revision_id(
 
100
            self._empty_merged_tag_2 + '--patch-1')
86
101
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
87
102
            pybaz.Version(self._empty_merged_tag_2))
88
103
        tree = pybaz.Revision(self._empty_merged_tag_2 + '--base-0').get (
102
117
        tree = pybaz.Revision(self._bad_id_tag + '--base-0').get(
103
118
            os.path.join(self._tmpdir, 'tree'))
104
119
        from bzrlib.plugins.bzrtools.baz_import import add_file
105
 
        add_file(os.path.join(self._tmpdir,'tree/path'), 'text', 'this_id/needs%escaping')
 
120
        add_file(os.path.join(self._tmpdir,'tree/path'), 'text', 
 
121
                 'this_id/needs%escaping')
106
122
        msg = tree.log_message()
107
123
        msg["summary"] = "commit something which needs escaping."
108
124
        tree.commit(msg)
110
126
 
111
127
        self.make_import_symlink()
112
128
        self.make_missing_ancestor()
 
129
        self.make_inbranch_continuation()
113
130
 
114
131
    def make_import_symlink(self):
115
132
        self._import_symlink = 'demo@DONOTUSE/c--import-symlink--0'
116
 
        self._import_symlink_bzr = revision_id(self._import_symlink + '--base-0')
 
133
        self._import_symlink_bzr = revision_id(
 
134
            self._import_symlink + '--base-0')
117
135
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
118
136
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
119
137
                               self._import_symlink)
120
 
        os.symlink('missing-file-name',
121
 
                   os.path.join(self._tmpdir, 'tree', 'alink'))
 
138
        link_path = os.path.join(self._tmpdir, 'tree', 'alink')
 
139
        os.symlink('missing-file-name', link_path)
122
140
        tree.add_tag('alink')
123
141
        id_file = open(os.path.join(tree, '.arch-ids', 'alink.id'), 'w')
124
142
        id_file.write('symlink_tag\n')
126
144
        msg = tree.log_message()
127
145
        msg["summary"] = "Import with a symlink"
128
146
        tree.import_(msg)
 
147
        os.unlink(link_path)
 
148
        f = file(link_path, 'w')
 
149
        f.write('Not a symlink no more!')
 
150
        f.close()
 
151
        msg = tree.log_message()
 
152
        msg["summary"] = "Turn a symlink into a file"
 
153
        tree.commit(msg)
129
154
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
130
155
 
131
156
    def make_empty_import(self):
132
157
        self._import = 'demo@DONOTUSE/c--import--0'
133
158
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
134
 
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), self._import)
 
159
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
160
                               self._import)
135
161
        msg = tree.log_message()
136
162
        msg["summary"] = "I am importing now"
137
163
        tree.import_(msg)
139
165
 
140
166
    def make_missing_ancestor(self):
141
167
        self._archivegoneroot = os.path.join(self._tmpdir, 'archivegone')
142
 
        self._archive = pybaz.make_archive('demo-gone@DONOTUSE',
143
 
                                           str(self._archivegoneroot))
 
168
        self._archive = make_archive('demo-gone@DONOTUSE',
 
169
                                     str(self._archivegoneroot))
144
170
        self._missing_import = 'demo-gone@DONOTUSE/c--import--0'
145
171
        self._missing_import_bzr = revision_id(self._missing_import 
146
172
                                                 + '--base-0')
159
185
            pybaz.Version(self._missing_ancestor))
160
186
 
161
187
        # make an import for testing history-reuse logic.
162
 
        def collect(text):
163
 
            pass
164
188
        # note the use of a namespace layout here.
165
189
        self._missing_import_imported = os.path.join(self._tmpdir, 
166
190
                                                     'archivegone-bzr')
168
192
        os.mkdir(os.path.join(self._tmpdir, 'archivegone-bzr', 'c'))
169
193
        import_version(os.path.join(self._tmpdir, 'archivegone-bzr', 
170
194
                                    'c', 'import'),
171
 
                       pybaz.Version(self._missing_import),
172
 
                       collect)
 
195
                       pybaz.Version(self._missing_import))
173
196
        # and make it inaccessible
174
197
        pybaz.Archive('demo-gone@DONOTUSE').unregister()
175
198
 
 
199
    def make_inbranch_continuation(self):
 
200
        self._inbranch_tag = 'demo@DONOTUSE/c--inbranch-tag--0'
 
201
        self._inbranch_tag_base = self._inbranch_tag + '--base-0'
 
202
        self._inbranch_tag_base_bzr = revision_id(self._inbranch_tag_base)
 
203
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
 
204
            pybaz.Version(self._inbranch_tag))
 
205
        self._inbranch_tag_head = self._inbranch_tag + '--patch-1'
 
206
        self._inbranch_tag_head_bzr = revision_id(self._inbranch_tag_head)
 
207
        pybaz.Revision(self._inbranch_tag_base).make_continuation(
 
208
            pybaz.Version(self._inbranch_tag))
 
209
 
176
210
    @classmethod
177
211
    def _makeResource(self):
178
212
        return BazTreeResource()
190
224
        TestCaseInTempDir.setUp(self)
191
225
        ResourcedTestCase.setUpResources(self)
192
226
        os.environ['HOME'] = self._baz._homedir
193
 
        self.output = StringIO()
194
227
 
195
228
    def tearDown(self):
196
229
        ResourcedTestCase.tearDownResources(self)
197
230
        TestCaseInTempDir.tearDown(self)
198
231
 
199
 
    def collect(self, text):
200
 
        self.output.write(text)
201
 
        self.output.write("\n")
202
 
 
203
232
    def test_import_empty(self):
204
 
        import_version('output', pybaz.Version(self._baz._import), self.collect)
 
233
        import_version('output', pybaz.Version(self._baz._import))
205
234
        # expected results:
206
 
        # one commit, no files, revision identifier of 'demo@DONOTUSE_c--import--0--base-0'
 
235
        # one commit, no files, revision identifier of 
 
236
        # 'demo@DONOTUSE_c--import--0--base-0'
207
237
        branch = Branch.open('output')
 
238
        repo = branch.repository
208
239
        self.assertEqual(branch.revision_history(),
209
240
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
210
 
        rev = branch.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
 
241
        rev = repo.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
211
242
        # and again.
212
 
        import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'),
213
 
                       self.collect)
 
243
        import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'))
214
244
        branch2 = Branch.open('output2')
 
245
        repo2 = branch2.repository
215
246
        self.assertEqual(branch.revision_history(), branch2.revision_history())
216
 
        rev2 = branch2.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
 
247
        rev2 = repo2.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
217
248
        # they must be the same
218
249
        self.assertEqual(rev, rev2)
219
250
 
224
255
                         "Arch-1:demo@DONOTUSE%c--import--0--base-0")
225
256
 
226
257
    def test_empty_tagged(self):
227
 
        import_version('output', pybaz.Version(self._baz._empty_tag),
228
 
                       self.collect)
 
258
        import_version('output', pybaz.Version(self._baz._empty_tag))
229
259
        # expected results:
230
260
        # two commits, no files, revision identifiers of 
231
261
        # 'demo@DONOTUSE_c--import--0--base-0' and
234
264
        self.assertEqual(branch.revision_history(),
235
265
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
236
266
                          self._baz._empty_tag_bzr])
237
 
        rev = branch.get_revision(self._baz._empty_tag_bzr)
 
267
        rev = branch.repository.get_revision(self._baz._empty_tag_bzr)
238
268
        # and again.
239
 
        import_version('output2', pybaz.Version(self._baz._empty_tag),
240
 
                       self.collect)
 
269
        import_version('output2', pybaz.Version(self._baz._empty_tag))
241
270
        branch2 = Branch.open('output2')
242
271
        self.assertEqual(branch.revision_history(), branch2.revision_history())
243
 
        rev2 = branch2.get_revision(self._baz._empty_tag_bzr)
 
272
        rev2 = branch2.repository.get_revision(self._baz._empty_tag_bzr)
244
273
        # they must be the same
245
274
        self.assertEqual(rev, rev2)
246
275
 
247
276
        # and we should get some expected values:
248
277
        self.assertEqual(rev.committer, "Test User<test@example.org>")
249
 
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
 
278
        self.assertEqual(rev.message, 
 
279
                         "tag of demo@DONOTUSE/c--import--0--base-0")
250
280
        self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)
251
281
 
252
282
    def test_empty_merged_tagged(self):
253
 
        import_version('output', pybaz.Version(self._baz._empty_merged_tag),
254
 
                       self.collect)
 
283
        import_version('output', pybaz.Version(self._baz._empty_merged_tag))
255
284
        # expected results:
256
285
        # two commits, no files, revision identifiers of 
257
286
        # 'demo@DONOTUSE_c--import--0--base-0' and
260
289
        # and a merged revision from the latter of
261
290
        # self._baz._empty_tag_bzr
262
291
        branch = Branch.open('output')
 
292
        repo = branch.repository
263
293
        self.assertEqual(branch.revision_history(),
264
294
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
265
295
                          self._baz._empty_merged_tag_bzr_base,
266
296
                          self._baz._empty_merged_tag_bzr])
267
297
        # and again.
268
 
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag),
269
 
                       self.collect)
 
298
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag))
270
299
        branch2 = Branch.open('output2')
 
300
        repo2 = branch2.repository
271
301
        # and import what we should be merged up against for checking with.
272
 
        import_version('output3', pybaz.Version(self._baz._empty_tag),
273
 
                       self.collect)
 
302
        import_version('output3', pybaz.Version(self._baz._empty_tag))
274
303
        branch3 = Branch.open('output3')
275
304
        
276
305
        self.assertEqual(branch.revision_history(), branch2.revision_history())
277
 
        self.assertNotEqual(branch.revision_history(), branch3.revision_history())
 
306
        self.assertNotEqual(branch.revision_history(), 
 
307
                            branch3.revision_history())
278
308
        # check revisions in the history.
279
 
        rev = branch.get_revision(self._baz._empty_merged_tag_bzr_base)
280
 
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_bzr_base)
 
309
        rev = repo.get_revision(self._baz._empty_merged_tag_bzr_base)
 
310
        rev2 = repo2.get_revision(self._baz._empty_merged_tag_bzr_base)
281
311
        # they must be the same
282
312
        self.assertEqual(rev, rev2)
283
313
        # and we should get some expected values:
284
314
        self.assertEqual(rev.committer, "Test User<test@example.org>")
285
 
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
 
315
        self.assertEqual(rev.message, 
 
316
                         "tag of demo@DONOTUSE/c--import--0--base-0")
286
317
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr_base)
287
318
        self.assertEqual(['Arch-1:demo@DONOTUSE%c--import--0--base-0'],
288
319
                         rev.parent_ids)
289
320
 
290
321
        # check next revisions in the history.
291
 
        rev = branch.get_revision(self._baz._empty_merged_tag_bzr)
292
 
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_bzr)
 
322
        rev = repo.get_revision(self._baz._empty_merged_tag_bzr)
 
323
        rev2 = repo2.get_revision(self._baz._empty_merged_tag_bzr)
293
324
        # they must be the same
294
325
        self.assertEqual(rev, rev2)
295
326
        # and we should get some expected values:
305
336
        # self.assertEqual(branch.missing_revisions(branch3), [])
306
337
        
307
338
    def test_merge_branch_with_merges(self):
308
 
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2),
309
 
                       self.collect)
 
339
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2))
310
340
        # expected results:
311
341
        # two commits, no files, revision identifiers of 
312
342
        # 'demo@DONOTUSE_c--import--0--base-0' and
315
345
        # and a merged revision from the latter of
316
346
        # self._baz._empty_merged_tag_bzr
317
347
        branch = Branch.open('output')
 
348
        repo = branch.repository
318
349
        self.assertEqual(branch.revision_history(),
319
350
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
320
351
                          self._baz._empty_merged_tag_2_bzr_base,
321
352
                          self._baz._empty_merged_tag_2_bzr])
322
353
        # and again.
323
 
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2),
324
 
                       self.collect)
 
354
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2))
325
355
        branch2 = Branch.open('output2')
 
356
        repo2 = branch2.repository
326
357
        # and import what we should be merged up against for checking with.
327
 
        import_version('output3', pybaz.Version(self._baz._empty_merged_tag),
328
 
                       self.collect)
 
358
        import_version('output3', pybaz.Version(self._baz._empty_merged_tag))
329
359
        branch3 = Branch.open('output3')
330
360
        
331
361
        self.assertEqual(branch.revision_history(), branch2.revision_history())
332
 
        self.assertNotEqual(branch.revision_history(), branch3.revision_history())
 
362
        self.assertNotEqual(branch.revision_history(), 
 
363
                            branch3.revision_history())
333
364
        # check revisions in the history.
334
 
        rev = branch.get_revision(self._baz._empty_merged_tag_2_bzr_base)
335
 
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_2_bzr_base)
 
365
        rev = repo.get_revision(self._baz._empty_merged_tag_2_bzr_base)
 
366
        rev2 = repo2.get_revision(self._baz._empty_merged_tag_2_bzr_base)
336
367
        # they must be the same
337
368
        self.assertEqual(rev, rev2)
338
369
        # and we should get some expected values:
339
370
        self.assertEqual(rev.committer, "Test User<test@example.org>")
340
 
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
341
 
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_2_bzr_base)
 
371
        self.assertEqual(rev.message, 
 
372
                         "tag of demo@DONOTUSE/c--import--0--base-0")
 
373
        self.assertEqual(rev.revision_id, 
 
374
                         self._baz._empty_merged_tag_2_bzr_base)
342
375
 
343
376
        # check next revisions in the history.
344
 
        rev = branch.get_revision(self._baz._empty_merged_tag_2_bzr)
345
 
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_2_bzr)
 
377
        rev = repo.get_revision(self._baz._empty_merged_tag_2_bzr)
 
378
        rev2 = repo2.get_revision(self._baz._empty_merged_tag_2_bzr)
346
379
        # they must be the same
347
380
        self.assertEqual(rev, rev2)
348
381
        # and we should get some expected values:
359
392
        # self.assertEqual(branch.missing_revisions(branch3), [])
360
393
        
361
394
    def test_import_symlink(self):
362
 
        import_version('output', pybaz.Version(self._baz._import_symlink),
363
 
                       self.collect)
 
395
        import_version('output', pybaz.Version(self._baz._import_symlink), 
 
396
                       max_count=1)
364
397
        # expected results:
365
 
        # one commit, no files, revision identifier of 'demo@DONOTUSE_c--import--0--base-0'
 
398
        # two commits, no files, revision identifier of 
 
399
        # 'demo@DONOTUSE_c--import--0--base-0'
366
400
        branch = Branch.open('output')
367
401
        self.assertEqual(branch.revision_history(),
368
402
                         [self._baz._import_symlink_bzr])
369
 
        rev = branch.get_revision(self._baz._import_symlink_bzr)
 
403
        rev = branch.repository.get_revision(self._baz._import_symlink_bzr)
370
404
        # and again.
371
405
        import_version('output2', pybaz.Version(self._baz._import_symlink),
372
 
                       self.collect)
 
406
                       max_count=1)
373
407
        branch2 = Branch.open('output2')
374
408
        self.assertEqual(branch.revision_history(), branch2.revision_history())
375
 
        rev2 = branch2.get_revision(self._baz._import_symlink_bzr)
 
409
        rev2 = branch2.repository.get_revision(self._baz._import_symlink_bzr)
376
410
        # they must be the same
377
411
        self.assertEqual(rev, rev2)
378
412
 
382
416
        self.assertEqual(rev.revision_id, self._baz._import_symlink_bzr)
383
417
 
384
418
        # and we want the symlink alink with target 'missing-file-name'
385
 
        inv = branch.get_inventory(rev.revision_id)
 
419
        inv = branch.repository.get_inventory(rev.revision_id)
386
420
        self.assertEqual(inv.path2id('alink'), 'x_symlink_tag')
387
421
        entry = inv['x_symlink_tag']
388
422
        self.assertEqual(entry.kind, 'symlink')
389
423
        self.assertEqual(entry.symlink_target, 'missing-file-name')
390
424
 
 
425
        # current bzr doesn't handle type changes
 
426
        self.assertRaises(AssertionError, import_version, 'output3',
 
427
                          pybaz.Version(self._baz._import_symlink))
 
428
 
391
429
    def test_missing_ancestor(self):
392
 
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
393
 
                       self.collect)
 
430
        import_version('output', pybaz.Version(self._baz._missing_ancestor))
394
431
        # expected results:
395
432
        # one commits, no files, revision identifiers of 
396
433
        # 'demo@DONOTUSE_c--gone--0--base-0' and
398
435
        branch = Branch.open('output')
399
436
        self.assertEqual(branch.revision_history(),
400
437
                         [self._baz._missing_ancestor_bzr])
401
 
        rev = branch.get_revision(self._baz._missing_ancestor_bzr)
 
438
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
402
439
        # and again.
403
 
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
404
 
                       self.collect)
 
440
        import_version('output2', pybaz.Version(self._baz._missing_ancestor))
405
441
        branch2 = Branch.open('output2')
406
442
        self.assertEqual(branch.revision_history(), branch2.revision_history())
407
 
        rev2 = branch2.get_revision(self._baz._missing_ancestor_bzr)
 
443
        rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)
408
444
        # they must be the same
409
445
        self.assertEqual(rev, rev2)
410
446
 
411
447
        # and we should get some expected values:
412
448
        self.assertEqual(rev.committer, "Test User<test@example.org>")
413
 
        self.assertEqual(rev.message, "tag of demo-gone@DONOTUSE/c--import--0--base-0")
 
449
        self.assertEqual(rev.message, 
 
450
                         "tag of demo-gone@DONOTUSE/c--import--0--base-0")
414
451
        self.assertEqual(rev.revision_id, self._baz._missing_ancestor_bzr)
415
452
        self.assertEqual(rev.parent_ids[0], self._baz._missing_import_bzr)
416
453
        self.assertEqual(1, len(rev.parent_ids))
417
454
 
418
455
        # must NOT be able to get the merged evision
419
 
        self.assertRaises(NoSuchRevision, branch.get_revision, 
 
456
        self.assertRaises(NoSuchRevision, branch.repository.get_revision, 
420
457
                          self._baz._missing_import_bzr)
421
458
 
422
459
    def test_missing_ancestor_reusing_history(self):
423
460
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
424
 
                       self.collect,
425
461
                       reuse_history_from=[self._baz._missing_import_imported])
426
462
        # expected results:
427
463
        # one commits, no files, revision identifiers of 
431
467
        self.assertEqual(branch.revision_history(),
432
468
                         [self._baz._missing_import_bzr,
433
469
                          self._baz._missing_ancestor_bzr])
434
 
        rev = branch.get_revision(self._baz._missing_ancestor_bzr)
 
470
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
435
471
        # and again.
436
472
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
437
 
                       self.collect,
438
473
                       reuse_history_from=[self._baz._missing_import_imported])
439
474
        branch2 = Branch.open('output2')
440
475
        self.assertEqual(branch.revision_history(), branch2.revision_history())
441
 
        rev2 = branch2.get_revision(self._baz._missing_ancestor_bzr)
 
476
        rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)
442
477
        # they must be the same
443
478
        self.assertEqual(rev, rev2)
444
479
 
445
480
        # must be able to get the missing base revision
446
 
        branch.get_revision(self._baz._missing_import_bzr)
 
481
        branch.repository.get_revision(self._baz._missing_import_bzr)
447
482
 
448
483
        # and we should get some expected values:
449
484
        self.assertEqual(rev.committer, "Test User<test@example.org>")
450
 
        self.assertEqual(rev.message, "tag of demo-gone@DONOTUSE/c--import--0--base-0")
 
485
        self.assertEqual(rev.message, 
 
486
                         "tag of demo-gone@DONOTUSE/c--import--0--base-0")
451
487
        self.assertEqual(rev.revision_id, self._baz._missing_ancestor_bzr)
452
488
        self.assertEqual(rev.parent_ids[0], self._baz._missing_import_bzr)
453
489
        self.assertEqual(1, len(rev.parent_ids))
454
490
 
455
491
    def test_bad_file_id(self):
456
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
457
 
                       self.collect)
 
492
        import_version('output', pybaz.Version(self._baz._bad_id_tag))
458
493
        # expected results:
459
494
        # three commits, one files, revision identifiers of 
460
495
        # 'demo@DONOTUSE_c--import--0--base-0' ,
465
500
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
466
501
                          self._baz._bad_id_tag_bzr_base,
467
502
                          self._baz._bad_id_tag_bzr])
468
 
        rev = branch.get_revision(self._baz._bad_id_tag_bzr)
469
 
        inv = branch.get_inventory(self._baz._bad_id_tag_bzr)
 
503
        rev = branch.repository.get_revision(self._baz._bad_id_tag_bzr)
 
504
        inv = branch.repository.get_inventory(self._baz._bad_id_tag_bzr)
470
505
        self.assertEqual(inv.path2id('path'), 'x_this_id%2fneeds%25escaping')
471
506
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
472
507
 
473
508
    def test_appending_revisions_already_present(self):
474
509
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
475
 
                       self.collect, max_count=2)
 
510
                       max_count=2)
476
511
        # expected results:
477
512
        # three commits, one files, revision identifiers of 
478
513
        # 'demo@DONOTUSE_c--import--0--base-0' ,
489
524
        self.assertEqual(branch.revision_history(),
490
525
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
491
526
        del branch
492
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
493
 
                       self.collect)
 
527
        import_version('output', pybaz.Version(self._baz._bad_id_tag))
494
528
        branch = Branch.open('output')
495
529
        self.assertEqual(branch.revision_history(),
496
530
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
497
531
                          self._baz._bad_id_tag_bzr_base,
498
532
                          self._baz._bad_id_tag_bzr])
499
 
        rev = branch.get_revision(self._baz._bad_id_tag_bzr)
500
 
        inv = branch.get_inventory(self._baz._bad_id_tag_bzr)
 
533
        rev = branch.repository.get_revision(self._baz._bad_id_tag_bzr)
 
534
        inv = branch.repository.get_inventory(self._baz._bad_id_tag_bzr)
501
535
        self.assertEqual(inv.path2id('path'), 'x_this_id%2fneeds%25escaping')
502
536
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
503
537
 
504
538
    def test_appending_revisions_all_already_present(self):
505
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
506
 
                       self.collect)
 
539
        import_version('output', pybaz.Version(self._baz._bad_id_tag))
507
540
        # expected results:
508
541
        # three commits, one files, revision identifiers of 
509
542
        # 'demo@DONOTUSE_c--import--0--base-0' ,
521
554
        self.assertEqual(branch.revision_history(),
522
555
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
523
556
        del branch
524
 
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
525
 
                       self.collect)
 
557
        import_version('output', pybaz.Version(self._baz._bad_id_tag))
526
558
        branch = Branch.open('output')
527
559
        self.assertEqual(branch.revision_history(),
528
560
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
529
561
                          self._baz._bad_id_tag_bzr_base,
530
562
                          self._baz._bad_id_tag_bzr])
531
 
        rev = branch.get_revision(self._baz._bad_id_tag_bzr)
532
 
        inv = branch.get_inventory(self._baz._bad_id_tag_bzr)
 
563
        rev = branch.repository.get_revision(self._baz._bad_id_tag_bzr)
 
564
        inv = branch.repository.get_inventory(self._baz._bad_id_tag_bzr)
533
565
        self.assertEqual(inv.path2id('path'), 'x_this_id%2fneeds%25escaping')
534
566
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
535
567
 
 
568
    def test_inbranch_conversion(self):
 
569
        import_version('output', pybaz.Version(self._baz._inbranch_tag))
 
570
        # expected results:
 
571
        # three commits, no files, revision identifiers of 
 
572
        # 'demo@DONOTUSE_c--import--0--base-0' and
 
573
        # self._baz._inbranch_tag_base_bzr
 
574
        # self._baz._inbranch_tag_head_bzr
 
575
        # with no merges.
 
576
        branch = Branch.open('output')
 
577
        self.assertEqual(branch.revision_history(),
 
578
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
 
579
                          self._baz._inbranch_tag_base_bzr,
 
580
                          self._baz._inbranch_tag_head_bzr])
 
581
        # and again.
 
582
        import_version('output2', pybaz.Version(self._baz._inbranch_tag))
 
583
        branch2 = Branch.open('output2')
 
584
        
 
585
        self.assertEqual(branch.revision_history(), branch2.revision_history())
 
586
        # check revisions in the history.
 
587
        rev = branch.repository.get_revision(self._baz._inbranch_tag_base_bzr)
 
588
        rev2 = branch2.repository.get_revision(self._baz._inbranch_tag_base_bzr)
 
589
        # they must be the same
 
590
        self.assertEqual(rev, rev2)
 
591
        # and we should get some expected values:
 
592
        self.assertEqual(rev.committer, "Test User<test@example.org>")
 
593
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
 
594
        self.assertEqual(rev.revision_id, self._baz._inbranch_tag_base_bzr)
 
595
 
 
596
        # check next revisions in the history.
 
597
        rev = branch.repository.get_revision(self._baz._inbranch_tag_head_bzr)
 
598
        rev2 = branch2.repository.get_revision(self._baz._inbranch_tag_head_bzr)
 
599
        # they must be the same
 
600
        self.assertEqual(rev, rev2)
 
601
        # and we should get some expected values:
 
602
        self.assertEqual(rev.committer, "Test User<test@example.org>")
 
603
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--inbranch-tag--0--base-0")
 
604
        self.assertEqual(rev.revision_id, self._baz._inbranch_tag_head_bzr)
 
605
        self.assertEqual(rev.parent_ids,
 
606
                         [self._baz._inbranch_tag_base_bzr])
 
607
 
 
608
    def test_no_commits_same_as_missing(self):
 
609
        path = 'output'
 
610
        os.mkdir(path)
 
611
        branch = bzrlib.bzrdir.BzrDir.create_branch_convenience(path)
 
612
        import_version(path, pybaz.Version(self._baz._import))
 
613
        # expected results:
 
614
        # one commit, revision identifier of 
 
615
        # 'demo@DONOTUSE_c--import--0--base-0'
 
616
        self.assertEqual(branch.revision_history(),
 
617
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
 
618
 
536
619
 
537
620
class TestNamespacePrevious(TestCase):
538
621
 
563
646
        self.assertEqual(namespace_previous(self.version['versionfix-3000']),
564
647
                         self.version['versionfix-2999'])
565
648
 
 
649
 
566
650
class TestNamespaceMapping(TestCase):
567
651
 
568
652
    def test_namespace_mapping_branch(self):
585
669
class TestFileIdMapping(TestCase):
586
670
 
587
671
    def test_slash(self):
588
 
        from bzrlib.plugins.bzrtools.baz_import import map_file_id
589
672
        self.assertEqual('c%2fc', map_file_id('c/c'))
590
673
        self.assertEqual('c%25c', map_file_id('c%c'))
591
674
 
600
683
        os.mkdir(self._homedir)
601
684
        os.environ['HOME'] = self._homedir
602
685
        self._archiveroot = os.path.join(self._tmpdir, 'archive')
603
 
        self._archive = pybaz.make_archive('demo@DONOTUSE', 
604
 
                                           str(self._archiveroot))
 
686
        self._archive = make_archive('demo@DONOTUSE', str(self._archiveroot))
605
687
 
606
688
    def tearDown(self):
607
689
        os.environ['HOME'] = self._oldhome
611
693
    def make_import(self, namespace):
612
694
        self._import = 'demo@DONOTUSE/%s' % namespace
613
695
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
614
 
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), self._import)
 
696
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
697
                               self._import)
615
698
        msg = tree.log_message()
616
699
        msg["summary"] = "I am importing now"
617
700
        tree.import_(msg)
624
707
        command = cmd_baz_import()
625
708
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
626
709
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output')))
627
 
        self.assertEqual(1, 
628
 
                        len(list(os.walk(os.path.join(self._tmpdir,'output')))))
 
710
        walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))
 
711
        self.assertEqual(7, walk_len)
629
712
 
630
713
    def test_two_branches(self):
631
714
        self.make_import('c--0')
633
716
        command = cmd_baz_import()
634
717
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
635
718
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output')))
636
 
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 'c','+trunk')))
637
 
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 'c1', '0.2','branch')))
638
 
        self.assertEqual(14,
639
 
                        len(list(os.walk(os.path.join(self._tmpdir,'output')))))
 
719
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 
 
720
                                       'c','+trunk')))
 
721
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 
 
722
                                                    'c1', '0.2','branch')))
 
723
        walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))
 
724
        self.assertEqual(20, walk_len)
640
725
 
641
726
    def test_run_twice(self):
642
727
        self.make_import('c--0')
643
728
        command = cmd_baz_import()
644
729
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
645
730
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
 
731
        
 
732
    def test_accepts_reuse_history(self):
 
733
        self.make_import('c--0')
 
734
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),
 
735
                     'demo@DONOTUSE', '.', '.')
 
736
        
 
737
    def test_does_not_need_reuse_history(self):
 
738
        self.make_import('c--0')
 
739
        self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),
 
740
                     'demo@DONOTUSE')
 
741