← 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-06-27 14:36:32 UTC
  • Revision ID: abentley@panoramicfeedback.com-20060627143632-0f4114d7b0a8d7d9
Fix zap for checkouts of branches with no parents

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_baz_import.py
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
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 baz_import import import_version, revision_id
26
 
from bzrlib.branch import find_branch
 
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)
27
34
import shutil
 
35
from StringIO import StringIO
28
36
import tempfile
29
37
from testresources import (TestResource, TestLoader, OptimisingTestSuite,
30
 
                           ResourcedTestCase)
 
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
 
46
from bzrlib.branch import Branch
31
47
 
32
48
def test_suite():
33
49
    if pybaz is None:
34
 
        return OptimisingTestSuite()
 
50
        from unittest import TestSuite
 
51
        return TestSuite()
35
52
    return TestLoader().loadTestsFromName(__name__)
36
53
 
37
54
 
47
64
        self._oldhome = os.environ['HOME']
48
65
        os.mkdir(self._homedir)
49
66
        os.environ['HOME'] = self._homedir
 
67
 
50
68
        self._archiveroot = os.path.join(self._tmpdir, 'archive')
51
 
 
52
 
        self._archive = pybaz.make_archive('demo@DONOTUSE', str(self._archiveroot))
 
69
        self._archive = make_archive('demo@DONOTUSE', str(self._archiveroot))
53
70
        pybaz.set_my_id("Test User<test@example.org>")
54
71
 
55
72
        self.make_empty_import()
77
94
        
78
95
        # tree, two commits, includes merge of other branch
79
96
        self._empty_merged_tag_2 = 'demo@DONOTUSE/c--empty-tag-2--0'
80
 
        self._empty_merged_tag_2_bzr_base = revision_id(self._empty_merged_tag_2 + '--base-0')
81
 
        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')
82
101
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
83
102
            pybaz.Version(self._empty_merged_tag_2))
84
103
        tree = pybaz.Revision(self._empty_merged_tag_2 + '--base-0').get (
90
109
        tree.commit(msg)
91
110
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
92
111
 
 
112
        self._bad_id_tag = 'demo@DONOTUSE/c--bad-id--0'
 
113
        self._bad_id_tag_bzr_base = revision_id(self._bad_id_tag + '--base-0')
 
114
        self._bad_id_tag_bzr = revision_id(self._bad_id_tag + '--patch-1')
 
115
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
 
116
            pybaz.Version(self._bad_id_tag))
 
117
        tree = pybaz.Revision(self._bad_id_tag + '--base-0').get(
 
118
            os.path.join(self._tmpdir, 'tree'))
 
119
        from bzrlib.plugins.bzrtools.baz_import import add_file
 
120
        add_file(os.path.join(self._tmpdir,'tree/path'), 'text', 
 
121
                 'this_id/needs%escaping')
 
122
        msg = tree.log_message()
 
123
        msg["summary"] = "commit something which needs escaping."
 
124
        tree.commit(msg)
 
125
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
 
126
 
93
127
        self.make_import_symlink()
 
128
        self.make_missing_ancestor()
 
129
        self.make_inbranch_continuation()
94
130
 
95
131
    def make_import_symlink(self):
96
132
        self._import_symlink = 'demo@DONOTUSE/c--import-symlink--0'
97
 
        self._import_symlink_bzr = revision_id(self._import_symlink + '--base-0')
 
133
        self._import_symlink_bzr = revision_id(
 
134
            self._import_symlink + '--base-0')
98
135
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
99
136
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
100
137
                               self._import_symlink)
101
 
        os.symlink('missing-file-name',
102
 
                   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)
103
140
        tree.add_tag('alink')
104
141
        id_file = open(os.path.join(tree, '.arch-ids', 'alink.id'), 'w')
105
142
        id_file.write('symlink_tag\n')
107
144
        msg = tree.log_message()
108
145
        msg["summary"] = "Import with a symlink"
109
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)
110
154
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
111
155
 
112
156
    def make_empty_import(self):
113
157
        self._import = 'demo@DONOTUSE/c--import--0'
114
158
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
115
 
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), self._import)
116
 
        msg = tree.log_message()
117
 
        msg["summary"] = "I am importing now"
118
 
        tree.import_(msg)
119
 
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
 
159
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
160
                               self._import)
 
161
        msg = tree.log_message()
 
162
        msg["summary"] = "I am importing now"
 
163
        tree.import_(msg)
 
164
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
 
165
 
 
166
    def make_missing_ancestor(self):
 
167
        self._archivegoneroot = os.path.join(self._tmpdir, 'archivegone')
 
168
        self._archive = make_archive('demo-gone@DONOTUSE',
 
169
                                     str(self._archivegoneroot))
 
170
        self._missing_import = 'demo-gone@DONOTUSE/c--import--0'
 
171
        self._missing_import_bzr = revision_id(self._missing_import 
 
172
                                                 + '--base-0')
 
173
        self._missing_ancestor = 'demo@DONOTUSE/c--gone--0'
 
174
        self._missing_ancestor_bzr = revision_id(self._missing_ancestor 
 
175
                                                 + '--base-0')
 
176
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
 
177
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
178
                               self._missing_import)
 
179
        msg = tree.log_message()
 
180
        msg["summary"] = "I am importing now"
 
181
        tree.import_(msg)
 
182
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
 
183
        # tag into the kept archive
 
184
        pybaz.Revision(self._missing_import + '--base-0').make_continuation(
 
185
            pybaz.Version(self._missing_ancestor))
 
186
 
 
187
        # make an import for testing history-reuse logic.
 
188
        # note the use of a namespace layout here.
 
189
        self._missing_import_imported = os.path.join(self._tmpdir, 
 
190
                                                     'archivegone-bzr')
 
191
        os.mkdir(os.path.join(self._tmpdir, 'archivegone-bzr'))
 
192
        os.mkdir(os.path.join(self._tmpdir, 'archivegone-bzr', 'c'))
 
193
        import_version(os.path.join(self._tmpdir, 'archivegone-bzr', 
 
194
                                    'c', 'import'),
 
195
                       pybaz.Version(self._missing_import))
 
196
        # and make it inaccessible
 
197
        pybaz.Archive('demo-gone@DONOTUSE').unregister()
 
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))
120
209
 
121
210
    @classmethod
122
211
    def _makeResource(self):
127
216
        resource.cleanUp()
128
217
 
129
218
 
130
 
class TestBazImport(TestCaseInTempDir):
 
219
class TestImportBranch(TestCaseInTempDir):
131
220
 
132
221
    _resources = [("_baz", BazTreeResource)]
133
222
 
134
223
    def setUp(self):
135
224
        TestCaseInTempDir.setUp(self)
136
225
        ResourcedTestCase.setUpResources(self)
 
226
        os.environ['HOME'] = self._baz._homedir
137
227
 
138
228
    def tearDown(self):
139
229
        ResourcedTestCase.tearDownResources(self)
140
230
        TestCaseInTempDir.tearDown(self)
141
 
        
 
231
 
142
232
    def test_import_empty(self):
143
233
        import_version('output', pybaz.Version(self._baz._import))
144
234
        # expected results:
145
 
        # one commit, no files, revision identifier of 'demo@DONOTUSE_c--import--0--base-0'
146
 
        branch = find_branch('output', find_root=False)
 
235
        # one commit, no files, revision identifier of 
 
236
        # 'demo@DONOTUSE_c--import--0--base-0'
 
237
        branch = Branch.open('output')
 
238
        repo = branch.repository
147
239
        self.assertEqual(branch.revision_history(),
148
240
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
149
 
        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')
150
242
        # and again.
151
243
        import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'))
152
 
        branch2 = find_branch('output2', find_root=False)
 
244
        branch2 = Branch.open('output2')
 
245
        repo2 = branch2.repository
153
246
        self.assertEqual(branch.revision_history(), branch2.revision_history())
154
 
        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')
155
248
        # they must be the same
156
249
        self.assertEqual(rev, rev2)
157
250
 
167
260
        # two commits, no files, revision identifiers of 
168
261
        # 'demo@DONOTUSE_c--import--0--base-0' and
169
262
        # self._baz._empty_tag_bzr
170
 
        branch = find_branch('output', find_root=False)
 
263
        branch = Branch.open('output')
171
264
        self.assertEqual(branch.revision_history(),
172
265
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
173
266
                          self._baz._empty_tag_bzr])
174
 
        rev = branch.get_revision(self._baz._empty_tag_bzr)
 
267
        rev = branch.repository.get_revision(self._baz._empty_tag_bzr)
175
268
        # and again.
176
269
        import_version('output2', pybaz.Version(self._baz._empty_tag))
177
 
        branch2 = find_branch('output2', find_root=False)
 
270
        branch2 = Branch.open('output2')
178
271
        self.assertEqual(branch.revision_history(), branch2.revision_history())
179
 
        rev2 = branch2.get_revision(self._baz._empty_tag_bzr)
 
272
        rev2 = branch2.repository.get_revision(self._baz._empty_tag_bzr)
180
273
        # they must be the same
181
274
        self.assertEqual(rev, rev2)
182
275
 
183
276
        # and we should get some expected values:
184
277
        self.assertEqual(rev.committer, "Test User<test@example.org>")
185
 
        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")
186
280
        self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)
187
281
 
188
282
    def test_empty_merged_tagged(self):
194
288
        # self._baz._empty_merged_tag_bzr
195
289
        # and a merged revision from the latter of
196
290
        # self._baz._empty_tag_bzr
197
 
        branch = find_branch('output', find_root=False)
 
291
        branch = Branch.open('output')
 
292
        repo = branch.repository
198
293
        self.assertEqual(branch.revision_history(),
199
294
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
200
295
                          self._baz._empty_merged_tag_bzr_base,
201
296
                          self._baz._empty_merged_tag_bzr])
202
297
        # and again.
203
298
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag))
204
 
        branch2 = find_branch('output2', find_root=False)
 
299
        branch2 = Branch.open('output2')
 
300
        repo2 = branch2.repository
205
301
        # and import what we should be merged up against for checking with.
206
302
        import_version('output3', pybaz.Version(self._baz._empty_tag))
207
 
        branch3 = find_branch('output3', find_root=False)
 
303
        branch3 = Branch.open('output3')
208
304
        
209
305
        self.assertEqual(branch.revision_history(), branch2.revision_history())
210
 
        self.assertNotEqual(branch.revision_history(), branch3.revision_history())
 
306
        self.assertNotEqual(branch.revision_history(), 
 
307
                            branch3.revision_history())
211
308
        # check revisions in the history.
212
 
        rev = branch.get_revision(self._baz._empty_merged_tag_bzr_base)
213
 
        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)
214
311
        # they must be the same
215
312
        self.assertEqual(rev, rev2)
216
313
        # and we should get some expected values:
217
314
        self.assertEqual(rev.committer, "Test User<test@example.org>")
218
 
        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")
219
317
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr_base)
 
318
        self.assertEqual(['Arch-1:demo@DONOTUSE%c--import--0--base-0'],
 
319
                         rev.parent_ids)
220
320
 
221
321
        # check next revisions in the history.
222
 
        rev = branch.get_revision(self._baz._empty_merged_tag_bzr)
223
 
        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)
224
324
        # they must be the same
225
325
        self.assertEqual(rev, rev2)
226
326
        # and we should get some expected values:
227
327
        self.assertEqual(rev.committer, "Test User<test@example.org>")
228
328
        self.assertEqual(rev.message, "did a merge, yarh")
229
329
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr)
230
 
        self.assertEqual(rev.parents[0].revision_id,
 
330
        self.assertEqual(rev.parent_ids[0],
231
331
                         self._baz._empty_merged_tag_bzr_base)
232
 
        self.assertEqual(rev.parents[1].revision_id,
233
 
                         self._baz._empty_tag_bzr)
 
332
        self.assertEqual(rev.parent_ids[1], self._baz._empty_tag_bzr)
234
333
 
235
334
        # this tree should have nothing missing from that tree.   
236
335
        # FIXME there is no code for this right now.
245
344
        # self._baz._empty_merged_tag_2_bzr
246
345
        # and a merged revision from the latter of
247
346
        # self._baz._empty_merged_tag_bzr
248
 
        branch = find_branch('output', find_root=False)
 
347
        branch = Branch.open('output')
 
348
        repo = branch.repository
249
349
        self.assertEqual(branch.revision_history(),
250
350
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
251
351
                          self._baz._empty_merged_tag_2_bzr_base,
252
352
                          self._baz._empty_merged_tag_2_bzr])
253
353
        # and again.
254
354
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2))
255
 
        branch2 = find_branch('output2', find_root=False)
 
355
        branch2 = Branch.open('output2')
 
356
        repo2 = branch2.repository
256
357
        # and import what we should be merged up against for checking with.
257
358
        import_version('output3', pybaz.Version(self._baz._empty_merged_tag))
258
 
        branch3 = find_branch('output3', find_root=False)
 
359
        branch3 = Branch.open('output3')
259
360
        
260
361
        self.assertEqual(branch.revision_history(), branch2.revision_history())
261
 
        self.assertNotEqual(branch.revision_history(), branch3.revision_history())
 
362
        self.assertNotEqual(branch.revision_history(), 
 
363
                            branch3.revision_history())
262
364
        # check revisions in the history.
263
 
        rev = branch.get_revision(self._baz._empty_merged_tag_2_bzr_base)
264
 
        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)
265
367
        # they must be the same
266
368
        self.assertEqual(rev, rev2)
267
369
        # and we should get some expected values:
268
370
        self.assertEqual(rev.committer, "Test User<test@example.org>")
269
 
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
270
 
        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)
271
375
 
272
376
        # check next revisions in the history.
273
 
        rev = branch.get_revision(self._baz._empty_merged_tag_2_bzr)
274
 
        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)
275
379
        # they must be the same
276
380
        self.assertEqual(rev, rev2)
277
381
        # and we should get some expected values:
278
382
        self.assertEqual(rev.committer, "Test User<test@example.org>")
279
383
        self.assertEqual(rev.message, "merge in a merged tree.")
280
384
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_2_bzr)
281
 
        self.assertEqual(rev.parents[0].revision_id,
 
385
        self.assertEqual(rev.parent_ids[0],
282
386
                         self._baz._empty_merged_tag_2_bzr_base)
283
 
        self.assertEqual(rev.parents[1].revision_id,
 
387
        self.assertEqual(rev.parent_ids[1],
284
388
                         self._baz._empty_merged_tag_bzr)
285
389
 
286
390
        # this tree should have nothing missing from that tree.   
288
392
        # self.assertEqual(branch.missing_revisions(branch3), [])
289
393
        
290
394
    def test_import_symlink(self):
291
 
        import_version('output', pybaz.Version(self._baz._import_symlink))
 
395
        import_version('output', pybaz.Version(self._baz._import_symlink), 
 
396
                       max_count=1)
292
397
        # expected results:
293
 
        # one commit, no files, revision identifier of 'demo@DONOTUSE_c--import--0--base-0'
294
 
        branch = find_branch('output', find_root=False)
 
398
        # two commits, no files, revision identifier of 
 
399
        # 'demo@DONOTUSE_c--import--0--base-0'
 
400
        branch = Branch.open('output')
295
401
        self.assertEqual(branch.revision_history(),
296
402
                         [self._baz._import_symlink_bzr])
297
 
        rev = branch.get_revision(self._baz._import_symlink_bzr)
 
403
        rev = branch.repository.get_revision(self._baz._import_symlink_bzr)
298
404
        # and again.
299
 
        import_version('output2', pybaz.Version(self._baz._import_symlink))
300
 
        branch2 = find_branch('output2', find_root=False)
 
405
        import_version('output2', pybaz.Version(self._baz._import_symlink),
 
406
                       max_count=1)
 
407
        branch2 = Branch.open('output2')
301
408
        self.assertEqual(branch.revision_history(), branch2.revision_history())
302
 
        rev2 = branch2.get_revision(self._baz._import_symlink_bzr)
 
409
        rev2 = branch2.repository.get_revision(self._baz._import_symlink_bzr)
303
410
        # they must be the same
304
411
        self.assertEqual(rev, rev2)
305
412
 
309
416
        self.assertEqual(rev.revision_id, self._baz._import_symlink_bzr)
310
417
 
311
418
        # and we want the symlink alink with target 'missing-file-name'
312
 
        inv = branch.get_inventory(rev.inventory_id)
 
419
        inv = branch.repository.get_inventory(rev.revision_id)
313
420
        self.assertEqual(inv.path2id('alink'), 'x_symlink_tag')
314
421
        entry = inv['x_symlink_tag']
315
422
        self.assertEqual(entry.kind, 'symlink')
316
423
        self.assertEqual(entry.symlink_target, 'missing-file-name')
 
424
 
 
425
        # current bzr doesn't handle type changes
 
426
        self.assertRaises(AssertionError, import_version, 'output3',
 
427
                          pybaz.Version(self._baz._import_symlink))
 
428
 
 
429
    def test_missing_ancestor(self):
 
430
        import_version('output', pybaz.Version(self._baz._missing_ancestor))
 
431
        # expected results:
 
432
        # one commits, no files, revision identifiers of 
 
433
        # 'demo@DONOTUSE_c--gone--0--base-0' and
 
434
        # a merge of demo-gone@DONOTUSE%c--import--0
 
435
        branch = Branch.open('output')
 
436
        self.assertEqual(branch.revision_history(),
 
437
                         [self._baz._missing_ancestor_bzr])
 
438
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
 
439
        # and again.
 
440
        import_version('output2', pybaz.Version(self._baz._missing_ancestor))
 
441
        branch2 = Branch.open('output2')
 
442
        self.assertEqual(branch.revision_history(), branch2.revision_history())
 
443
        rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)
 
444
        # they must be the same
 
445
        self.assertEqual(rev, rev2)
 
446
 
 
447
        # and we should get some expected values:
 
448
        self.assertEqual(rev.committer, "Test User<test@example.org>")
 
449
        self.assertEqual(rev.message, 
 
450
                         "tag of demo-gone@DONOTUSE/c--import--0--base-0")
 
451
        self.assertEqual(rev.revision_id, self._baz._missing_ancestor_bzr)
 
452
        self.assertEqual(rev.parent_ids[0], self._baz._missing_import_bzr)
 
453
        self.assertEqual(1, len(rev.parent_ids))
 
454
 
 
455
        # must NOT be able to get the merged evision
 
456
        self.assertRaises(NoSuchRevision, branch.repository.get_revision, 
 
457
                          self._baz._missing_import_bzr)
 
458
 
 
459
    def test_missing_ancestor_reusing_history(self):
 
460
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
 
461
                       reuse_history_from=[self._baz._missing_import_imported])
 
462
        # expected results:
 
463
        # one commits, no files, revision identifiers of 
 
464
        # 'demo-gone@DONOTUSE%c--import--0--base-0' and 
 
465
        # 'demo@DONOTUSE%c--gone--0--base-0'
 
466
        branch = Branch.open('output')
 
467
        self.assertEqual(branch.revision_history(),
 
468
                         [self._baz._missing_import_bzr,
 
469
                          self._baz._missing_ancestor_bzr])
 
470
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
 
471
        # and again.
 
472
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
 
473
                       reuse_history_from=[self._baz._missing_import_imported])
 
474
        branch2 = Branch.open('output2')
 
475
        self.assertEqual(branch.revision_history(), branch2.revision_history())
 
476
        rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)
 
477
        # they must be the same
 
478
        self.assertEqual(rev, rev2)
 
479
 
 
480
        # must be able to get the missing base revision
 
481
        branch.repository.get_revision(self._baz._missing_import_bzr)
 
482
 
 
483
        # and we should get some expected values:
 
484
        self.assertEqual(rev.committer, "Test User<test@example.org>")
 
485
        self.assertEqual(rev.message, 
 
486
                         "tag of demo-gone@DONOTUSE/c--import--0--base-0")
 
487
        self.assertEqual(rev.revision_id, self._baz._missing_ancestor_bzr)
 
488
        self.assertEqual(rev.parent_ids[0], self._baz._missing_import_bzr)
 
489
        self.assertEqual(1, len(rev.parent_ids))
 
490
 
 
491
    def test_bad_file_id(self):
 
492
        import_version('output', pybaz.Version(self._baz._bad_id_tag))
 
493
        # expected results:
 
494
        # three commits, one files, revision identifiers of 
 
495
        # 'demo@DONOTUSE_c--import--0--base-0' ,
 
496
        # 'demo@DONOTUSE/c--bad-id--0--base-0' ,
 
497
        # ''demo@DONOTUSE/c--bad-id--0--patch-1'
 
498
        branch = Branch.open('output')
 
499
        self.assertEqual(branch.revision_history(),
 
500
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
 
501
                          self._baz._bad_id_tag_bzr_base,
 
502
                          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)
 
505
        self.assertEqual(inv.path2id('path'), 'x_this_id%2fneeds%25escaping')
 
506
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
 
507
 
 
508
    def test_appending_revisions_already_present(self):
 
509
        import_version('output', pybaz.Version(self._baz._bad_id_tag),
 
510
                       max_count=2)
 
511
        # expected results:
 
512
        # three commits, one files, revision identifiers of 
 
513
        # 'demo@DONOTUSE_c--import--0--base-0' ,
 
514
        # 'demo@DONOTUSE/c--bad-id--0--base-0' ,
 
515
        # ''demo@DONOTUSE/c--bad-id--0--patch-1'
 
516
        branch = Branch.open('output')
 
517
        self.assertEqual(branch.revision_history(),
 
518
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
 
519
                          self._baz._bad_id_tag_bzr_base])
 
520
        branch.set_revision_history(
 
521
            ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
 
522
        del branch
 
523
        branch = Branch.open('output')
 
524
        self.assertEqual(branch.revision_history(),
 
525
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
 
526
        del branch
 
527
        import_version('output', pybaz.Version(self._baz._bad_id_tag))
 
528
        branch = Branch.open('output')
 
529
        self.assertEqual(branch.revision_history(),
 
530
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
 
531
                          self._baz._bad_id_tag_bzr_base,
 
532
                          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)
 
535
        self.assertEqual(inv.path2id('path'), 'x_this_id%2fneeds%25escaping')
 
536
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
 
537
 
 
538
    def test_appending_revisions_all_already_present(self):
 
539
        import_version('output', pybaz.Version(self._baz._bad_id_tag))
 
540
        # expected results:
 
541
        # three commits, one files, revision identifiers of 
 
542
        # 'demo@DONOTUSE_c--import--0--base-0' ,
 
543
        # 'demo@DONOTUSE/c--bad-id--0--base-0' ,
 
544
        # ''demo@DONOTUSE/c--bad-id--0--patch-1'
 
545
        branch = Branch.open('output')
 
546
        self.assertEqual(branch.revision_history(),
 
547
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
 
548
                          self._baz._bad_id_tag_bzr_base,
 
549
                          self._baz._bad_id_tag_bzr])
 
550
        branch.set_revision_history(
 
551
            ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
 
552
        del branch
 
553
        branch = Branch.open('output')
 
554
        self.assertEqual(branch.revision_history(),
 
555
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
 
556
        del branch
 
557
        import_version('output', pybaz.Version(self._baz._bad_id_tag))
 
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
        rev = branch.repository.get_revision(self._baz._bad_id_tag_bzr)
 
564
        inv = branch.repository.get_inventory(self._baz._bad_id_tag_bzr)
 
565
        self.assertEqual(inv.path2id('path'), 'x_this_id%2fneeds%25escaping')
 
566
        self.assertEqual('path', inv.id2path('x_this_id%2fneeds%25escaping'))
 
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
 
 
619
 
 
620
class TestNamespacePrevious(TestCase):
 
621
 
 
622
    def setUp(self):
 
623
        TestCase.setUp(self)
 
624
        self.version = pybaz.Version('foo@example.com/c--b--0')
 
625
 
 
626
    def test_base0_none(self):
 
627
        self.assertEqual(namespace_previous(self.version['base-0']), None)
 
628
 
 
629
    def test_patch1_base0(self):
 
630
        self.assertEqual(namespace_previous(self.version['patch-1']),
 
631
                         self.version['base-0'])
 
632
        
 
633
    def test_patch3000_patch2999(self):
 
634
        self.assertEqual(namespace_previous(self.version['patch-3000']),
 
635
                         self.version['patch-2999'])
 
636
        
 
637
    def test_version0_raises(self):
 
638
        self.assertRaises(RuntimeError, namespace_previous,
 
639
                          self.version['version-0'])
 
640
 
 
641
    def test_version1_version0(self):
 
642
        self.assertEqual(namespace_previous(self.version['versionfix-1']),
 
643
                         self.version['version-0'])
 
644
 
 
645
    def test_version3000_patch2999(self):
 
646
        self.assertEqual(namespace_previous(self.version['versionfix-3000']),
 
647
                         self.version['versionfix-2999'])
 
648
 
 
649
 
 
650
class TestNamespaceMapping(TestCase):
 
651
 
 
652
    def test_namespace_mapping_branch(self):
 
653
        from bzrlib.plugins.bzrtools.baz_import import map_namespace
 
654
        branch = pybaz.Branch('foo@example.com/c--b')
 
655
        self.assertRaises(pybaz.errors.NamespaceError, map_namespace, branch)
 
656
        self.assertEqual('c/b', map_namespace(branch['0']))
 
657
        self.assertEqual('c/0.1/b', map_namespace(branch['0.1']))
 
658
 
 
659
    def test_namespace_mapping_no_branch(self):
 
660
        from bzrlib.plugins.bzrtools.baz_import import map_namespace
 
661
        category = pybaz.Category('foo@example.com/c')
 
662
        self.assertRaises(pybaz.errors.NamespaceError, map_namespace, category)
 
663
        self.assertEqual('c/+trunk', 
 
664
                         map_namespace(pybaz.Version("%s--0" % category)))
 
665
        self.assertEqual('c/0.1/+trunk',
 
666
                         map_namespace(pybaz.Version('%s--0.1' % category)))
 
667
 
 
668
 
 
669
class TestFileIdMapping(TestCase):
 
670
 
 
671
    def test_slash(self):
 
672
        self.assertEqual('c%2fc', map_file_id('c/c'))
 
673
        self.assertEqual('c%25c', map_file_id('c%c'))
 
674
 
 
675
 
 
676
class TestImport(TestCaseInTempDir):
 
677
 
 
678
    def setUp(self):
 
679
        TestCaseInTempDir.setUp(self)
 
680
        self._oldhome = os.environ['HOME']
 
681
        self._tmpdir = tempfile.mkdtemp()
 
682
        self._homedir = os.path.join(self._tmpdir, 'home')
 
683
        os.mkdir(self._homedir)
 
684
        os.environ['HOME'] = self._homedir
 
685
        self._archiveroot = os.path.join(self._tmpdir, 'archive')
 
686
        self._archive = make_archive('demo@DONOTUSE', str(self._archiveroot))
 
687
 
 
688
    def tearDown(self):
 
689
        os.environ['HOME'] = self._oldhome
 
690
        shutil.rmtree(self._tmpdir)
 
691
        TestCaseInTempDir.tearDown(self)
 
692
 
 
693
    def make_import(self, namespace):
 
694
        self._import = 'demo@DONOTUSE/%s' % namespace
 
695
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
 
696
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
697
                               self._import)
 
698
        msg = tree.log_message()
 
699
        msg["summary"] = "I am importing now"
 
700
        tree.import_(msg)
 
701
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
 
702
 
 
703
    def test_cmd_exists(self):
 
704
        from bzrlib.plugins.bzrtools.baz_import import cmd_baz_import
 
705
 
 
706
    def test_empty_archive(self):
 
707
        command = cmd_baz_import()
 
708
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
 
709
        self.failUnless(os.path.exists(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)
 
712
 
 
713
    def test_two_branches(self):
 
714
        self.make_import('c--0')
 
715
        self.make_import('c1--branch--0.2')
 
716
        command = cmd_baz_import()
 
717
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
 
718
        self.failUnless(os.path.exists(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)
 
725
 
 
726
    def test_run_twice(self):
 
727
        self.make_import('c--0')
 
728
        command = cmd_baz_import()
 
729
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
 
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