← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to tests/test_baz_import.py

  • Committer: Robert Collins
  • Date: 2005-09-13 10:46:27 UTC
  • mto: (147.2.6) (364.1.3 bzrtools)
  • mto: This revision was merged to the branch mainline in revision 324.
  • Revision ID: robertc@robertcollins.net-20050913104627-51f938950a907475
handle inaccessible sibling archives somewhat - note version-0 is still not handled

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.tests import TestCaseInTempDir, TestCase
19
 
from bzrlib.osutils import has_symlinks
 
18
from bzrlib.selftest import TestCaseInTempDir, TestCase
 
19
from bzrlib.selftest.blackbox import has_symlinks
20
20
try:
21
21
    import pybaz
22
22
except ImportError:
23
23
    pybaz = None
24
24
import os
25
 
try:
26
 
    from bzrtools.baz_import import (import_version, revision_id,
27
 
                                     cmd_baz_import, make_archive, map_file_id)
28
 
except ImportError:
29
 
    from bzrlib.plugins.bzrtools.baz_import import (import_version, 
30
 
                                                    revision_id,
31
 
                                                    cmd_baz_import,
32
 
                                                    make_archive,
33
 
                                                    map_file_id)
 
25
from baz_import import import_version, revision_id
 
26
from bzrlib.branch import find_branch
34
27
import shutil
35
 
from StringIO import StringIO
36
28
import tempfile
37
29
from testresources import (TestResource, TestLoader, OptimisingTestSuite,
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
 
30
                           ResourcedTestCase)
 
31
from fai.cmdutil import namespace_previous
47
32
 
48
33
def test_suite():
49
34
    if pybaz is None:
50
 
        from unittest import TestSuite
51
 
        return TestSuite()
 
35
        return OptimisingTestSuite()
52
36
    return TestLoader().loadTestsFromName(__name__)
53
37
 
54
38
 
64
48
        self._oldhome = os.environ['HOME']
65
49
        os.mkdir(self._homedir)
66
50
        os.environ['HOME'] = self._homedir
 
51
        self._archiveroot = os.path.join(self._tmpdir, 'archive')
67
52
 
68
 
        self._archiveroot = os.path.join(self._tmpdir, 'archive')
69
 
        self._archive = make_archive('demo@DONOTUSE', str(self._archiveroot))
 
53
        self._archive = pybaz.make_archive('demo@DONOTUSE', str(self._archiveroot))
70
54
        pybaz.set_my_id("Test User<test@example.org>")
71
55
 
72
56
        self.make_empty_import()
94
78
        
95
79
        # tree, two commits, includes merge of other branch
96
80
        self._empty_merged_tag_2 = 'demo@DONOTUSE/c--empty-tag-2--0'
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')
 
81
        self._empty_merged_tag_2_bzr_base = revision_id(self._empty_merged_tag_2 + '--base-0')
 
82
        self._empty_merged_tag_2_bzr = revision_id(self._empty_merged_tag_2 + '--patch-1')
101
83
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
102
84
            pybaz.Version(self._empty_merged_tag_2))
103
85
        tree = pybaz.Revision(self._empty_merged_tag_2 + '--base-0').get (
109
91
        tree.commit(msg)
110
92
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
111
93
 
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
 
 
127
94
        self.make_import_symlink()
128
 
        self.make_missing_ancestor()
129
 
        self.make_inbranch_continuation()
130
95
 
131
96
    def make_import_symlink(self):
132
97
        self._import_symlink = 'demo@DONOTUSE/c--import-symlink--0'
133
 
        self._import_symlink_bzr = revision_id(
134
 
            self._import_symlink + '--base-0')
 
98
        self._import_symlink_bzr = revision_id(self._import_symlink + '--base-0')
135
99
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
136
100
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
137
101
                               self._import_symlink)
138
 
        link_path = os.path.join(self._tmpdir, 'tree', 'alink')
139
 
        os.symlink('missing-file-name', link_path)
 
102
        os.symlink('missing-file-name',
 
103
                   os.path.join(self._tmpdir, 'tree', 'alink'))
140
104
        tree.add_tag('alink')
141
105
        id_file = open(os.path.join(tree, '.arch-ids', 'alink.id'), 'w')
142
106
        id_file.write('symlink_tag\n')
144
108
        msg = tree.log_message()
145
109
        msg["summary"] = "Import with a symlink"
146
110
        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)
154
111
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
155
112
 
156
113
    def make_empty_import(self):
157
114
        self._import = 'demo@DONOTUSE/c--import--0'
158
115
        os.mkdir(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))
 
116
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), self._import)
 
117
        msg = tree.log_message()
 
118
        msg["summary"] = "I am importing now"
 
119
        tree.import_(msg)
 
120
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
209
121
 
210
122
    @classmethod
211
123
    def _makeResource(self):
216
128
        resource.cleanUp()
217
129
 
218
130
 
219
 
class TestImportBranch(TestCaseInTempDir):
 
131
class TestBazImport(TestCaseInTempDir):
220
132
 
221
133
    _resources = [("_baz", BazTreeResource)]
222
134
 
223
135
    def setUp(self):
224
136
        TestCaseInTempDir.setUp(self)
225
137
        ResourcedTestCase.setUpResources(self)
226
 
        os.environ['HOME'] = self._baz._homedir
227
138
 
228
139
    def tearDown(self):
229
140
        ResourcedTestCase.tearDownResources(self)
230
141
        TestCaseInTempDir.tearDown(self)
231
 
 
 
142
        
232
143
    def test_import_empty(self):
233
144
        import_version('output', pybaz.Version(self._baz._import))
234
145
        # expected results:
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
 
146
        # one commit, no files, revision identifier of 'demo@DONOTUSE_c--import--0--base-0'
 
147
        branch = find_branch('output', find_root=False)
239
148
        self.assertEqual(branch.revision_history(),
240
149
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
241
 
        rev = repo.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
 
150
        rev = branch.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
242
151
        # and again.
243
152
        import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'))
244
 
        branch2 = Branch.open('output2')
245
 
        repo2 = branch2.repository
 
153
        branch2 = find_branch('output2', find_root=False)
246
154
        self.assertEqual(branch.revision_history(), branch2.revision_history())
247
 
        rev2 = repo2.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
 
155
        rev2 = branch2.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
248
156
        # they must be the same
249
157
        self.assertEqual(rev, rev2)
250
158
 
260
168
        # two commits, no files, revision identifiers of 
261
169
        # 'demo@DONOTUSE_c--import--0--base-0' and
262
170
        # self._baz._empty_tag_bzr
263
 
        branch = Branch.open('output')
 
171
        branch = find_branch('output', find_root=False)
264
172
        self.assertEqual(branch.revision_history(),
265
173
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
266
174
                          self._baz._empty_tag_bzr])
267
 
        rev = branch.repository.get_revision(self._baz._empty_tag_bzr)
 
175
        rev = branch.get_revision(self._baz._empty_tag_bzr)
268
176
        # and again.
269
177
        import_version('output2', pybaz.Version(self._baz._empty_tag))
270
 
        branch2 = Branch.open('output2')
 
178
        branch2 = find_branch('output2', find_root=False)
271
179
        self.assertEqual(branch.revision_history(), branch2.revision_history())
272
 
        rev2 = branch2.repository.get_revision(self._baz._empty_tag_bzr)
 
180
        rev2 = branch2.get_revision(self._baz._empty_tag_bzr)
273
181
        # they must be the same
274
182
        self.assertEqual(rev, rev2)
275
183
 
276
184
        # and we should get some expected values:
277
185
        self.assertEqual(rev.committer, "Test User<test@example.org>")
278
 
        self.assertEqual(rev.message, 
279
 
                         "tag of demo@DONOTUSE/c--import--0--base-0")
 
186
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
280
187
        self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)
281
188
 
282
189
    def test_empty_merged_tagged(self):
288
195
        # self._baz._empty_merged_tag_bzr
289
196
        # and a merged revision from the latter of
290
197
        # self._baz._empty_tag_bzr
291
 
        branch = Branch.open('output')
292
 
        repo = branch.repository
 
198
        branch = find_branch('output', find_root=False)
293
199
        self.assertEqual(branch.revision_history(),
294
200
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
295
201
                          self._baz._empty_merged_tag_bzr_base,
296
202
                          self._baz._empty_merged_tag_bzr])
297
203
        # and again.
298
204
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag))
299
 
        branch2 = Branch.open('output2')
300
 
        repo2 = branch2.repository
 
205
        branch2 = find_branch('output2', find_root=False)
301
206
        # and import what we should be merged up against for checking with.
302
207
        import_version('output3', pybaz.Version(self._baz._empty_tag))
303
 
        branch3 = Branch.open('output3')
 
208
        branch3 = find_branch('output3', find_root=False)
304
209
        
305
210
        self.assertEqual(branch.revision_history(), branch2.revision_history())
306
 
        self.assertNotEqual(branch.revision_history(), 
307
 
                            branch3.revision_history())
 
211
        self.assertNotEqual(branch.revision_history(), branch3.revision_history())
308
212
        # check revisions in the history.
309
 
        rev = repo.get_revision(self._baz._empty_merged_tag_bzr_base)
310
 
        rev2 = repo2.get_revision(self._baz._empty_merged_tag_bzr_base)
 
213
        rev = branch.get_revision(self._baz._empty_merged_tag_bzr_base)
 
214
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_bzr_base)
311
215
        # they must be the same
312
216
        self.assertEqual(rev, rev2)
313
217
        # and we should get some expected values:
314
218
        self.assertEqual(rev.committer, "Test User<test@example.org>")
315
 
        self.assertEqual(rev.message, 
316
 
                         "tag of demo@DONOTUSE/c--import--0--base-0")
 
219
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
317
220
        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)
320
221
 
321
222
        # check next revisions in the history.
322
 
        rev = repo.get_revision(self._baz._empty_merged_tag_bzr)
323
 
        rev2 = repo2.get_revision(self._baz._empty_merged_tag_bzr)
 
223
        rev = branch.get_revision(self._baz._empty_merged_tag_bzr)
 
224
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_bzr)
324
225
        # they must be the same
325
226
        self.assertEqual(rev, rev2)
326
227
        # and we should get some expected values:
327
228
        self.assertEqual(rev.committer, "Test User<test@example.org>")
328
229
        self.assertEqual(rev.message, "did a merge, yarh")
329
230
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr)
330
 
        self.assertEqual(rev.parent_ids[0],
 
231
        self.assertEqual(rev.parents[0].revision_id,
331
232
                         self._baz._empty_merged_tag_bzr_base)
332
 
        self.assertEqual(rev.parent_ids[1], self._baz._empty_tag_bzr)
 
233
        self.assertEqual(rev.parents[1].revision_id,
 
234
                         self._baz._empty_tag_bzr)
333
235
 
334
236
        # this tree should have nothing missing from that tree.   
335
237
        # FIXME there is no code for this right now.
344
246
        # self._baz._empty_merged_tag_2_bzr
345
247
        # and a merged revision from the latter of
346
248
        # self._baz._empty_merged_tag_bzr
347
 
        branch = Branch.open('output')
348
 
        repo = branch.repository
 
249
        branch = find_branch('output', find_root=False)
349
250
        self.assertEqual(branch.revision_history(),
350
251
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
351
252
                          self._baz._empty_merged_tag_2_bzr_base,
352
253
                          self._baz._empty_merged_tag_2_bzr])
353
254
        # and again.
354
255
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2))
355
 
        branch2 = Branch.open('output2')
356
 
        repo2 = branch2.repository
 
256
        branch2 = find_branch('output2', find_root=False)
357
257
        # and import what we should be merged up against for checking with.
358
258
        import_version('output3', pybaz.Version(self._baz._empty_merged_tag))
359
 
        branch3 = Branch.open('output3')
 
259
        branch3 = find_branch('output3', find_root=False)
360
260
        
361
261
        self.assertEqual(branch.revision_history(), branch2.revision_history())
362
 
        self.assertNotEqual(branch.revision_history(), 
363
 
                            branch3.revision_history())
 
262
        self.assertNotEqual(branch.revision_history(), branch3.revision_history())
364
263
        # check revisions in the history.
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)
 
264
        rev = branch.get_revision(self._baz._empty_merged_tag_2_bzr_base)
 
265
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_2_bzr_base)
367
266
        # they must be the same
368
267
        self.assertEqual(rev, rev2)
369
268
        # and we should get some expected values:
370
269
        self.assertEqual(rev.committer, "Test User<test@example.org>")
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)
 
270
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
 
271
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_2_bzr_base)
375
272
 
376
273
        # check next revisions in the history.
377
 
        rev = repo.get_revision(self._baz._empty_merged_tag_2_bzr)
378
 
        rev2 = repo2.get_revision(self._baz._empty_merged_tag_2_bzr)
 
274
        rev = branch.get_revision(self._baz._empty_merged_tag_2_bzr)
 
275
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_2_bzr)
379
276
        # they must be the same
380
277
        self.assertEqual(rev, rev2)
381
278
        # and we should get some expected values:
382
279
        self.assertEqual(rev.committer, "Test User<test@example.org>")
383
280
        self.assertEqual(rev.message, "merge in a merged tree.")
384
281
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_2_bzr)
385
 
        self.assertEqual(rev.parent_ids[0],
 
282
        self.assertEqual(rev.parents[0].revision_id,
386
283
                         self._baz._empty_merged_tag_2_bzr_base)
387
 
        self.assertEqual(rev.parent_ids[1],
 
284
        self.assertEqual(rev.parents[1].revision_id,
388
285
                         self._baz._empty_merged_tag_bzr)
389
286
 
390
287
        # this tree should have nothing missing from that tree.   
392
289
        # self.assertEqual(branch.missing_revisions(branch3), [])
393
290
        
394
291
    def test_import_symlink(self):
395
 
        import_version('output', pybaz.Version(self._baz._import_symlink), 
396
 
                       max_count=1)
 
292
        import_version('output', pybaz.Version(self._baz._import_symlink))
397
293
        # expected results:
398
 
        # two commits, no files, revision identifier of 
399
 
        # 'demo@DONOTUSE_c--import--0--base-0'
400
 
        branch = Branch.open('output')
 
294
        # one commit, no files, revision identifier of 'demo@DONOTUSE_c--import--0--base-0'
 
295
        branch = find_branch('output', find_root=False)
401
296
        self.assertEqual(branch.revision_history(),
402
297
                         [self._baz._import_symlink_bzr])
403
 
        rev = branch.repository.get_revision(self._baz._import_symlink_bzr)
 
298
        rev = branch.get_revision(self._baz._import_symlink_bzr)
404
299
        # and again.
405
 
        import_version('output2', pybaz.Version(self._baz._import_symlink),
406
 
                       max_count=1)
407
 
        branch2 = Branch.open('output2')
 
300
        import_version('output2', pybaz.Version(self._baz._import_symlink))
 
301
        branch2 = find_branch('output2', find_root=False)
408
302
        self.assertEqual(branch.revision_history(), branch2.revision_history())
409
 
        rev2 = branch2.repository.get_revision(self._baz._import_symlink_bzr)
 
303
        rev2 = branch2.get_revision(self._baz._import_symlink_bzr)
410
304
        # they must be the same
411
305
        self.assertEqual(rev, rev2)
412
306
 
416
310
        self.assertEqual(rev.revision_id, self._baz._import_symlink_bzr)
417
311
 
418
312
        # and we want the symlink alink with target 'missing-file-name'
419
 
        inv = branch.repository.get_inventory(rev.revision_id)
 
313
        inv = branch.get_inventory(rev.inventory_id)
420
314
        self.assertEqual(inv.path2id('alink'), 'x_symlink_tag')
421
315
        entry = inv['x_symlink_tag']
422
316
        self.assertEqual(entry.kind, 'symlink')
423
317
        self.assertEqual(entry.symlink_target, 'missing-file-name')
424
318
 
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
319
 
620
320
class TestNamespacePrevious(TestCase):
621
321
 
639
339
                          self.version['version-0'])
640
340
 
641
341
    def test_version1_version0(self):
642
 
        self.assertEqual(namespace_previous(self.version['versionfix-1']),
 
342
        self.assertEqual(namespace_previous(self.version['version-1']),
643
343
                         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