← 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: 2006-12-12 16:50:31 UTC
  • Revision ID: abentley@panoramicfeedback.com-20061212165031-51w8gjy1eps1vnw0
update NEWS

Show diffs side-by-side

added added

removed removed

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