1
# Copyright (C) 2005 Canonical Limited
2
# Authors: Robert Collins <robert.collins@canonical.com>
4
# This program is free software; you can redistribute it and/or modify
5
# it under the terms of the GNU General Public License as published by
6
# the Free Software Foundation; either version 2 of the License, or
7
# (at your option) any later version.
9
# This program is distributed in the hope that it will be useful,
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12
# GNU General Public License for more details.
14
# You should have received a copy of the GNU General Public License
15
# along with this program; if not, write to the Free Software
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
from bzrlib.tests import TestCaseInTempDir, TestCase
19
from bzrlib.osutils import has_symlinks
26
from bzrtools.baz_import import (import_version, revision_id,
27
cmd_baz_import, make_archive, map_file_id)
29
from bzrlib.plugins.bzrtools.baz_import import (import_version,
34
from bzrlib.errors import NoSuchRevision
36
from StringIO import StringIO
38
from testresources import (TestResource, TestLoader, OptimisingTestSuite,
42
from bzrtools.fai import namespace_previous
44
from bzrlib.plugins.bzrtools.fai import namespace_previous
45
from bzrlib.branch import Branch
49
from unittest import TestSuite
51
return TestLoader().loadTestsFromName(__name__)
54
class BazTreeResource(TestResource):
57
os.environ['HOME'] = self._oldhome
58
shutil.rmtree(self._tmpdir)
61
self._tmpdir = tempfile.mkdtemp()
62
self._homedir = os.path.join(self._tmpdir, 'home')
63
self._oldhome = os.environ['HOME']
64
os.mkdir(self._homedir)
65
os.environ['HOME'] = self._homedir
67
self._archiveroot = os.path.join(self._tmpdir, 'archive')
68
self._archive = make_archive('demo@DONOTUSE', str(self._archiveroot))
69
pybaz.set_my_id("Test User<test@example.org>")
71
self.make_empty_import()
73
self._empty_tag = 'demo@DONOTUSE/c--empty-tag--0'
74
self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0')
75
pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
76
pybaz.Version(self._empty_tag))
78
self._empty_merged_tag = 'demo@DONOTUSE/c--empty-merged-tag--0'
79
self._empty_merged_tag_bzr_base = revision_id(self._empty_merged_tag
81
self._empty_merged_tag_bzr = revision_id(self._empty_merged_tag
83
pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
84
pybaz.Version(self._empty_merged_tag))
85
tree = pybaz.Revision(self._empty_merged_tag + '--base-0').get(
86
os.path.join(self._tmpdir, 'tree'))
87
tree.star_merge(self._empty_tag,
88
pybaz.Version('demo@DONOTUSE/c--import--0'))
89
msg = tree.log_message()
90
msg["summary"]="did a merge, yarh"
92
shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
94
# tree, two commits, includes merge of other branch
95
self._empty_merged_tag_2 = 'demo@DONOTUSE/c--empty-tag-2--0'
96
self._empty_merged_tag_2_bzr_base = revision_id(
97
self._empty_merged_tag_2 + '--base-0')
98
self._empty_merged_tag_2_bzr = revision_id(
99
self._empty_merged_tag_2 + '--patch-1')
100
pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
101
pybaz.Version(self._empty_merged_tag_2))
102
tree = pybaz.Revision(self._empty_merged_tag_2 + '--base-0').get (
103
os.path.join(self._tmpdir, 'tree'))
104
tree.star_merge(self._empty_merged_tag,
105
pybaz.Version('demo@DONOTUSE/c--import--0'))
106
msg = tree.log_message()
107
msg["summary"] = "merge in a merged tree."
109
shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
111
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')
114
pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
115
pybaz.Version(self._bad_id_tag))
116
tree = pybaz.Revision(self._bad_id_tag + '--base-0').get(
117
os.path.join(self._tmpdir, 'tree'))
118
from bzrlib.plugins.bzrtools.baz_import import add_file
119
add_file(os.path.join(self._tmpdir,'tree/path'), 'text',
120
'this_id/needs%escaping')
121
msg = tree.log_message()
122
msg["summary"] = "commit something which needs escaping."
124
shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
126
self.make_import_symlink()
127
self.make_missing_ancestor()
128
self.make_inbranch_continuation()
130
def make_import_symlink(self):
131
self._import_symlink = 'demo@DONOTUSE/c--import-symlink--0'
132
self._import_symlink_bzr = revision_id(
133
self._import_symlink + '--base-0')
134
os.mkdir(os.path.join(self._tmpdir, 'tree'))
135
tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
136
self._import_symlink)
137
os.symlink('missing-file-name',
138
os.path.join(self._tmpdir, 'tree', 'alink'))
139
tree.add_tag('alink')
140
id_file = open(os.path.join(tree, '.arch-ids', 'alink.id'), 'w')
141
id_file.write('symlink_tag\n')
143
msg = tree.log_message()
144
msg["summary"] = "Import with a symlink"
146
shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
148
def make_empty_import(self):
149
self._import = 'demo@DONOTUSE/c--import--0'
150
os.mkdir(os.path.join(self._tmpdir, 'tree'))
151
tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
153
msg = tree.log_message()
154
msg["summary"] = "I am importing now"
156
shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
158
def make_missing_ancestor(self):
159
self._archivegoneroot = os.path.join(self._tmpdir, 'archivegone')
160
self._archive = make_archive('demo-gone@DONOTUSE',
161
str(self._archivegoneroot))
162
self._missing_import = 'demo-gone@DONOTUSE/c--import--0'
163
self._missing_import_bzr = revision_id(self._missing_import
165
self._missing_ancestor = 'demo@DONOTUSE/c--gone--0'
166
self._missing_ancestor_bzr = revision_id(self._missing_ancestor
168
os.mkdir(os.path.join(self._tmpdir, 'tree'))
169
tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
170
self._missing_import)
171
msg = tree.log_message()
172
msg["summary"] = "I am importing now"
174
shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
175
# tag into the kept archive
176
pybaz.Revision(self._missing_import + '--base-0').make_continuation(
177
pybaz.Version(self._missing_ancestor))
179
# make an import for testing history-reuse logic.
182
# note the use of a namespace layout here.
183
self._missing_import_imported = os.path.join(self._tmpdir,
185
os.mkdir(os.path.join(self._tmpdir, 'archivegone-bzr'))
186
os.mkdir(os.path.join(self._tmpdir, 'archivegone-bzr', 'c'))
187
import_version(os.path.join(self._tmpdir, 'archivegone-bzr',
189
pybaz.Version(self._missing_import),
191
# and make it inaccessible
192
pybaz.Archive('demo-gone@DONOTUSE').unregister()
194
def make_inbranch_continuation(self):
195
self._inbranch_tag = 'demo@DONOTUSE/c--inbranch-tag--0'
196
self._inbranch_tag_base = self._inbranch_tag + '--base-0'
197
self._inbranch_tag_base_bzr = revision_id(self._inbranch_tag_base)
198
pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
199
pybaz.Version(self._inbranch_tag))
200
self._inbranch_tag_head = self._inbranch_tag + '--patch-1'
201
self._inbranch_tag_head_bzr = revision_id(self._inbranch_tag_head)
202
pybaz.Revision(self._inbranch_tag_base).make_continuation(
203
pybaz.Version(self._inbranch_tag))
206
def _makeResource(self):
207
return BazTreeResource()
210
def _cleanResource(self, resource):
214
class TestImportBranch(TestCaseInTempDir):
216
_resources = [("_baz", BazTreeResource)]
219
TestCaseInTempDir.setUp(self)
220
ResourcedTestCase.setUpResources(self)
221
os.environ['HOME'] = self._baz._homedir
222
self.output = StringIO()
225
ResourcedTestCase.tearDownResources(self)
226
TestCaseInTempDir.tearDown(self)
228
def collect(self, text):
229
self.output.write(text)
230
self.output.write("\n")
232
def test_import_empty(self):
233
import_version('output', pybaz.Version(self._baz._import),
236
# one commit, no files, revision identifier of
237
# 'demo@DONOTUSE_c--import--0--base-0'
238
branch = Branch.open('output')
239
repo = branch.repository
240
self.assertEqual(branch.revision_history(),
241
['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
242
rev = repo.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
244
import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'),
246
branch2 = Branch.open('output2')
247
repo2 = branch2.repository
248
self.assertEqual(branch.revision_history(), branch2.revision_history())
249
rev2 = repo2.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
250
# they must be the same
251
self.assertEqual(rev, rev2)
253
# and we should get some expected values:
254
self.assertEqual(rev.committer, "Test User<test@example.org>")
255
self.assertEqual(rev.message, "I am importing now")
256
self.assertEqual(rev.revision_id,
257
"Arch-1:demo@DONOTUSE%c--import--0--base-0")
259
def test_empty_tagged(self):
260
import_version('output', pybaz.Version(self._baz._empty_tag),
263
# two commits, no files, revision identifiers of
264
# 'demo@DONOTUSE_c--import--0--base-0' and
265
# self._baz._empty_tag_bzr
266
branch = Branch.open('output')
267
self.assertEqual(branch.revision_history(),
268
['Arch-1:demo@DONOTUSE%c--import--0--base-0',
269
self._baz._empty_tag_bzr])
270
rev = branch.repository.get_revision(self._baz._empty_tag_bzr)
272
import_version('output2', pybaz.Version(self._baz._empty_tag),
274
branch2 = Branch.open('output2')
275
self.assertEqual(branch.revision_history(), branch2.revision_history())
276
rev2 = branch2.repository.get_revision(self._baz._empty_tag_bzr)
277
# they must be the same
278
self.assertEqual(rev, rev2)
280
# and we should get some expected values:
281
self.assertEqual(rev.committer, "Test User<test@example.org>")
282
self.assertEqual(rev.message,
283
"tag of demo@DONOTUSE/c--import--0--base-0")
284
self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)
286
def test_empty_merged_tagged(self):
287
import_version('output', pybaz.Version(self._baz._empty_merged_tag),
290
# two commits, no files, revision identifiers of
291
# 'demo@DONOTUSE_c--import--0--base-0' and
292
# self._baz._empty_merged_tag_bzr_base
293
# self._baz._empty_merged_tag_bzr
294
# and a merged revision from the latter of
295
# self._baz._empty_tag_bzr
296
branch = Branch.open('output')
297
repo = branch.repository
298
self.assertEqual(branch.revision_history(),
299
['Arch-1:demo@DONOTUSE%c--import--0--base-0',
300
self._baz._empty_merged_tag_bzr_base,
301
self._baz._empty_merged_tag_bzr])
303
import_version('output2', pybaz.Version(self._baz._empty_merged_tag),
305
branch2 = Branch.open('output2')
306
repo2 = branch2.repository
307
# and import what we should be merged up against for checking with.
308
import_version('output3', pybaz.Version(self._baz._empty_tag),
310
branch3 = Branch.open('output3')
312
self.assertEqual(branch.revision_history(), branch2.revision_history())
313
self.assertNotEqual(branch.revision_history(),
314
branch3.revision_history())
315
# check revisions in the history.
316
rev = repo.get_revision(self._baz._empty_merged_tag_bzr_base)
317
rev2 = repo2.get_revision(self._baz._empty_merged_tag_bzr_base)
318
# they must be the same
319
self.assertEqual(rev, rev2)
320
# and we should get some expected values:
321
self.assertEqual(rev.committer, "Test User<test@example.org>")
322
self.assertEqual(rev.message,
323
"tag of demo@DONOTUSE/c--import--0--base-0")
324
self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr_base)
325
self.assertEqual(['Arch-1:demo@DONOTUSE%c--import--0--base-0'],
328
# check next revisions in the history.
329
rev = repo.get_revision(self._baz._empty_merged_tag_bzr)
330
rev2 = repo2.get_revision(self._baz._empty_merged_tag_bzr)
331
# they must be the same
332
self.assertEqual(rev, rev2)
333
# and we should get some expected values:
334
self.assertEqual(rev.committer, "Test User<test@example.org>")
335
self.assertEqual(rev.message, "did a merge, yarh")
336
self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr)
337
self.assertEqual(rev.parent_ids[0],
338
self._baz._empty_merged_tag_bzr_base)
339
self.assertEqual(rev.parent_ids[1], self._baz._empty_tag_bzr)
341
# this tree should have nothing missing from that tree.
342
# FIXME there is no code for this right now.
343
# self.assertEqual(branch.missing_revisions(branch3), [])
345
def test_merge_branch_with_merges(self):
346
import_version('output', pybaz.Version(self._baz._empty_merged_tag_2),
349
# two commits, no files, revision identifiers of
350
# 'demo@DONOTUSE_c--import--0--base-0' and
351
# self._baz._empty_merged_tag_2_bzr_base
352
# self._baz._empty_merged_tag_2_bzr
353
# and a merged revision from the latter of
354
# self._baz._empty_merged_tag_bzr
355
branch = Branch.open('output')
356
repo = branch.repository
357
self.assertEqual(branch.revision_history(),
358
['Arch-1:demo@DONOTUSE%c--import--0--base-0',
359
self._baz._empty_merged_tag_2_bzr_base,
360
self._baz._empty_merged_tag_2_bzr])
362
import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2),
364
branch2 = Branch.open('output2')
365
repo2 = branch2.repository
366
# and import what we should be merged up against for checking with.
367
import_version('output3', pybaz.Version(self._baz._empty_merged_tag),
369
branch3 = Branch.open('output3')
371
self.assertEqual(branch.revision_history(), branch2.revision_history())
372
self.assertNotEqual(branch.revision_history(),
373
branch3.revision_history())
374
# check revisions in the history.
375
rev = repo.get_revision(self._baz._empty_merged_tag_2_bzr_base)
376
rev2 = repo2.get_revision(self._baz._empty_merged_tag_2_bzr_base)
377
# they must be the same
378
self.assertEqual(rev, rev2)
379
# and we should get some expected values:
380
self.assertEqual(rev.committer, "Test User<test@example.org>")
381
self.assertEqual(rev.message,
382
"tag of demo@DONOTUSE/c--import--0--base-0")
383
self.assertEqual(rev.revision_id,
384
self._baz._empty_merged_tag_2_bzr_base)
386
# check next revisions in the history.
387
rev = repo.get_revision(self._baz._empty_merged_tag_2_bzr)
388
rev2 = repo2.get_revision(self._baz._empty_merged_tag_2_bzr)
389
# they must be the same
390
self.assertEqual(rev, rev2)
391
# and we should get some expected values:
392
self.assertEqual(rev.committer, "Test User<test@example.org>")
393
self.assertEqual(rev.message, "merge in a merged tree.")
394
self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_2_bzr)
395
self.assertEqual(rev.parent_ids[0],
396
self._baz._empty_merged_tag_2_bzr_base)
397
self.assertEqual(rev.parent_ids[1],
398
self._baz._empty_merged_tag_bzr)
400
# this tree should have nothing missing from that tree.
401
# FIXME there is no code for this right now.
402
# self.assertEqual(branch.missing_revisions(branch3), [])
404
def test_import_symlink(self):
405
import_version('output', pybaz.Version(self._baz._import_symlink),
408
# one commit, no files, revision identifier of
409
# 'demo@DONOTUSE_c--import--0--base-0'
410
branch = Branch.open('output')
411
self.assertEqual(branch.revision_history(),
412
[self._baz._import_symlink_bzr])
413
rev = branch.repository.get_revision(self._baz._import_symlink_bzr)
415
import_version('output2', pybaz.Version(self._baz._import_symlink),
417
branch2 = Branch.open('output2')
418
self.assertEqual(branch.revision_history(), branch2.revision_history())
419
rev2 = branch2.repository.get_revision(self._baz._import_symlink_bzr)
420
# they must be the same
421
self.assertEqual(rev, rev2)
423
# and we should get some expected values:
424
self.assertEqual(rev.committer, "Test User<test@example.org>")
425
self.assertEqual(rev.message, "Import with a symlink")
426
self.assertEqual(rev.revision_id, self._baz._import_symlink_bzr)
428
# and we want the symlink alink with target 'missing-file-name'
429
inv = branch.repository.get_inventory(rev.revision_id)
430
self.assertEqual(inv.path2id('alink'), 'x_symlink_tag')
431
entry = inv['x_symlink_tag']
432
self.assertEqual(entry.kind, 'symlink')
433
self.assertEqual(entry.symlink_target, 'missing-file-name')
435
def test_missing_ancestor(self):
436
import_version('output', pybaz.Version(self._baz._missing_ancestor),
439
# one commits, no files, revision identifiers of
440
# 'demo@DONOTUSE_c--gone--0--base-0' and
441
# a merge of demo-gone@DONOTUSE%c--import--0
442
branch = Branch.open('output')
443
self.assertEqual(branch.revision_history(),
444
[self._baz._missing_ancestor_bzr])
445
rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
447
import_version('output2', pybaz.Version(self._baz._missing_ancestor),
449
branch2 = Branch.open('output2')
450
self.assertEqual(branch.revision_history(), branch2.revision_history())
451
rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)
452
# they must be the same
453
self.assertEqual(rev, rev2)
455
# and we should get some expected values:
456
self.assertEqual(rev.committer, "Test User<test@example.org>")
457
self.assertEqual(rev.message,
458
"tag of demo-gone@DONOTUSE/c--import--0--base-0")
459
self.assertEqual(rev.revision_id, self._baz._missing_ancestor_bzr)
460
self.assertEqual(rev.parent_ids[0], self._baz._missing_import_bzr)
461
self.assertEqual(1, len(rev.parent_ids))
463
# must NOT be able to get the merged evision
464
self.assertRaises(NoSuchRevision, branch.repository.get_revision,
465
self._baz._missing_import_bzr)
467
def test_missing_ancestor_reusing_history(self):
468
import_version('output', pybaz.Version(self._baz._missing_ancestor),
470
reuse_history_from=[self._baz._missing_import_imported])
472
# one commits, no files, revision identifiers of
473
# 'demo-gone@DONOTUSE%c--import--0--base-0' and
474
# 'demo@DONOTUSE%c--gone--0--base-0'
475
branch = Branch.open('output')
476
self.assertEqual(branch.revision_history(),
477
[self._baz._missing_import_bzr,
478
self._baz._missing_ancestor_bzr])
479
rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
481
import_version('output2', pybaz.Version(self._baz._missing_ancestor),
483
reuse_history_from=[self._baz._missing_import_imported])
484
branch2 = Branch.open('output2')
485
self.assertEqual(branch.revision_history(), branch2.revision_history())
486
rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)
487
# they must be the same
488
self.assertEqual(rev, rev2)
490
# must be able to get the missing base revision
491
branch.repository.get_revision(self._baz._missing_import_bzr)
493
# and we should get some expected values:
494
self.assertEqual(rev.committer, "Test User<test@example.org>")
495
self.assertEqual(rev.message,
496
"tag of demo-gone@DONOTUSE/c--import--0--base-0")
497
self.assertEqual(rev.revision_id, self._baz._missing_ancestor_bzr)
498
self.assertEqual(rev.parent_ids[0], self._baz._missing_import_bzr)
499
self.assertEqual(1, len(rev.parent_ids))
501
def test_bad_file_id(self):
502
import_version('output', pybaz.Version(self._baz._bad_id_tag),
505
# three commits, one files, revision identifiers of
506
# 'demo@DONOTUSE_c--import--0--base-0' ,
507
# 'demo@DONOTUSE/c--bad-id--0--base-0' ,
508
# ''demo@DONOTUSE/c--bad-id--0--patch-1'
509
branch = Branch.open('output')
510
self.assertEqual(branch.revision_history(),
511
['Arch-1:demo@DONOTUSE%c--import--0--base-0',
512
self._baz._bad_id_tag_bzr_base,
513
self._baz._bad_id_tag_bzr])
514
rev = branch.repository.get_revision(self._baz._bad_id_tag_bzr)
515
inv = branch.repository.get_inventory(self._baz._bad_id_tag_bzr)
516
self.assertEqual(inv.path2id('path'), 'x_this_id%2fneeds%25escaping')
517
self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
519
def test_appending_revisions_already_present(self):
520
import_version('output', pybaz.Version(self._baz._bad_id_tag),
521
self.collect, max_count=2)
523
# three commits, one files, revision identifiers of
524
# 'demo@DONOTUSE_c--import--0--base-0' ,
525
# 'demo@DONOTUSE/c--bad-id--0--base-0' ,
526
# ''demo@DONOTUSE/c--bad-id--0--patch-1'
527
branch = Branch.open('output')
528
self.assertEqual(branch.revision_history(),
529
['Arch-1:demo@DONOTUSE%c--import--0--base-0',
530
self._baz._bad_id_tag_bzr_base])
531
branch.set_revision_history(
532
['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
534
branch = Branch.open('output')
535
self.assertEqual(branch.revision_history(),
536
['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
538
import_version('output', pybaz.Version(self._baz._bad_id_tag),
540
branch = Branch.open('output')
541
self.assertEqual(branch.revision_history(),
542
['Arch-1:demo@DONOTUSE%c--import--0--base-0',
543
self._baz._bad_id_tag_bzr_base,
544
self._baz._bad_id_tag_bzr])
545
rev = branch.repository.get_revision(self._baz._bad_id_tag_bzr)
546
inv = branch.repository.get_inventory(self._baz._bad_id_tag_bzr)
547
self.assertEqual(inv.path2id('path'), 'x_this_id%2fneeds%25escaping')
548
self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
550
def test_appending_revisions_all_already_present(self):
551
import_version('output', pybaz.Version(self._baz._bad_id_tag),
554
# three commits, one files, revision identifiers of
555
# 'demo@DONOTUSE_c--import--0--base-0' ,
556
# 'demo@DONOTUSE/c--bad-id--0--base-0' ,
557
# ''demo@DONOTUSE/c--bad-id--0--patch-1'
558
branch = Branch.open('output')
559
self.assertEqual(branch.revision_history(),
560
['Arch-1:demo@DONOTUSE%c--import--0--base-0',
561
self._baz._bad_id_tag_bzr_base,
562
self._baz._bad_id_tag_bzr])
563
branch.set_revision_history(
564
['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
566
branch = Branch.open('output')
567
self.assertEqual(branch.revision_history(),
568
['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
570
import_version('output', pybaz.Version(self._baz._bad_id_tag),
572
branch = Branch.open('output')
573
self.assertEqual(branch.revision_history(),
574
['Arch-1:demo@DONOTUSE%c--import--0--base-0',
575
self._baz._bad_id_tag_bzr_base,
576
self._baz._bad_id_tag_bzr])
577
rev = branch.repository.get_revision(self._baz._bad_id_tag_bzr)
578
inv = branch.repository.get_inventory(self._baz._bad_id_tag_bzr)
579
self.assertEqual(inv.path2id('path'), 'x_this_id%2fneeds%25escaping')
580
self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
582
def test_inbranch_conversion(self):
583
import_version('output', pybaz.Version(self._baz._inbranch_tag),
586
# three commits, no files, revision identifiers of
587
# 'demo@DONOTUSE_c--import--0--base-0' and
588
# self._baz._inbranch_tag_base_bzr
589
# self._baz._inbranch_tag_head_bzr
591
branch = Branch.open('output')
592
self.assertEqual(branch.revision_history(),
593
['Arch-1:demo@DONOTUSE%c--import--0--base-0',
594
self._baz._inbranch_tag_base_bzr,
595
self._baz._inbranch_tag_head_bzr])
597
import_version('output2', pybaz.Version(self._baz._inbranch_tag),
599
branch2 = Branch.open('output2')
601
self.assertEqual(branch.revision_history(), branch2.revision_history())
602
# check revisions in the history.
603
rev = branch.repository.get_revision(self._baz._inbranch_tag_base_bzr)
604
rev2 = branch2.repository.get_revision(self._baz._inbranch_tag_base_bzr)
605
# they must be the same
606
self.assertEqual(rev, rev2)
607
# and we should get some expected values:
608
self.assertEqual(rev.committer, "Test User<test@example.org>")
609
self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
610
self.assertEqual(rev.revision_id, self._baz._inbranch_tag_base_bzr)
612
# check next revisions in the history.
613
rev = branch.repository.get_revision(self._baz._inbranch_tag_head_bzr)
614
rev2 = branch2.repository.get_revision(self._baz._inbranch_tag_head_bzr)
615
# they must be the same
616
self.assertEqual(rev, rev2)
617
# and we should get some expected values:
618
self.assertEqual(rev.committer, "Test User<test@example.org>")
619
self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--inbranch-tag--0--base-0")
620
self.assertEqual(rev.revision_id, self._baz._inbranch_tag_head_bzr)
621
self.assertEqual(rev.parent_ids,
622
[self._baz._inbranch_tag_base_bzr])
625
class TestNamespacePrevious(TestCase):
629
self.version = pybaz.Version('foo@example.com/c--b--0')
631
def test_base0_none(self):
632
self.assertEqual(namespace_previous(self.version['base-0']), None)
634
def test_patch1_base0(self):
635
self.assertEqual(namespace_previous(self.version['patch-1']),
636
self.version['base-0'])
638
def test_patch3000_patch2999(self):
639
self.assertEqual(namespace_previous(self.version['patch-3000']),
640
self.version['patch-2999'])
642
def test_version0_raises(self):
643
self.assertRaises(RuntimeError, namespace_previous,
644
self.version['version-0'])
646
def test_version1_version0(self):
647
self.assertEqual(namespace_previous(self.version['versionfix-1']),
648
self.version['version-0'])
650
def test_version3000_patch2999(self):
651
self.assertEqual(namespace_previous(self.version['versionfix-3000']),
652
self.version['versionfix-2999'])
654
class TestNamespaceMapping(TestCase):
656
def test_namespace_mapping_branch(self):
657
from bzrlib.plugins.bzrtools.baz_import import map_namespace
658
branch = pybaz.Branch('foo@example.com/c--b')
659
self.assertRaises(pybaz.errors.NamespaceError, map_namespace, branch)
660
self.assertEqual('c/b', map_namespace(branch['0']))
661
self.assertEqual('c/0.1/b', map_namespace(branch['0.1']))
663
def test_namespace_mapping_no_branch(self):
664
from bzrlib.plugins.bzrtools.baz_import import map_namespace
665
category = pybaz.Category('foo@example.com/c')
666
self.assertRaises(pybaz.errors.NamespaceError, map_namespace, category)
667
self.assertEqual('c/+trunk',
668
map_namespace(pybaz.Version("%s--0" % category)))
669
self.assertEqual('c/0.1/+trunk',
670
map_namespace(pybaz.Version('%s--0.1' % category)))
673
class TestFileIdMapping(TestCase):
675
def test_slash(self):
676
self.assertEqual('c%2fc', map_file_id('c/c'))
677
self.assertEqual('c%25c', map_file_id('c%c'))
680
class TestImport(TestCaseInTempDir):
683
TestCaseInTempDir.setUp(self)
684
self._oldhome = os.environ['HOME']
685
self._tmpdir = tempfile.mkdtemp()
686
self._homedir = os.path.join(self._tmpdir, 'home')
687
os.mkdir(self._homedir)
688
os.environ['HOME'] = self._homedir
689
self._archiveroot = os.path.join(self._tmpdir, 'archive')
690
self._archive = make_archive('demo@DONOTUSE', str(self._archiveroot))
693
os.environ['HOME'] = self._oldhome
694
shutil.rmtree(self._tmpdir)
695
TestCaseInTempDir.tearDown(self)
697
def make_import(self, namespace):
698
self._import = 'demo@DONOTUSE/%s' % namespace
699
os.mkdir(os.path.join(self._tmpdir, 'tree'))
700
tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
702
msg = tree.log_message()
703
msg["summary"] = "I am importing now"
705
shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
707
def test_cmd_exists(self):
708
from bzrlib.plugins.bzrtools.baz_import import cmd_baz_import
710
def test_empty_archive(self):
711
command = cmd_baz_import()
712
command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
713
self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output')))
714
walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))
715
self.assertEqual(7, walk_len)
717
def test_two_branches(self):
718
self.make_import('c--0')
719
self.make_import('c1--branch--0.2')
720
command = cmd_baz_import()
721
command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
722
self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output')))
723
self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output',
725
self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output',
726
'c1', '0.2','branch')))
727
walk_len = len(list(os.walk(os.path.join(self._tmpdir,'output'))))
728
self.assertEqual(22, walk_len)
730
def test_run_twice(self):
731
self.make_import('c--0')
732
command = cmd_baz_import()
733
command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
734
command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
736
def test_accepts_reuse_history(self):
737
self.make_import('c--0')
738
self.run_bzr('baz-import', os.path.join(self._tmpdir, 'output'),
739
'demo@DONOTUSE', '.', '.')
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'),
added
removed
tests/test_baz_import.py
