← 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-11-30 03:18:39 UTC
  • Revision ID: aaron.bentley@utoronto.ca-20061130031839-q2s2ixzkebyrc9qq
Change recommendation to pybaz 1.5

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, TestCase
19
 
from bzrlib.selftest.blackbox import has_symlinks
 
18
from bzrlib.tests import TestCaseInTempDir, TestCase
 
19
from bzrlib import repository
 
20
from bzrlib.osutils import has_symlinks
20
21
try:
21
22
    import pybaz
22
23
except ImportError:
23
24
    pybaz = None
24
25
import os
25
 
from baz_import import import_version, revision_id, cmd_baz_import
26
 
from bzrlib.errors import NoSuchRevision
 
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)
27
36
import shutil
28
37
from StringIO import StringIO
29
38
import tempfile
30
39
from testresources import (TestResource, TestLoader, OptimisingTestSuite,
31
 
                           ResourcedTestCase)
32
 
from fai import namespace_previous
 
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
33
48
from bzrlib.branch import Branch
34
49
 
35
50
def test_suite():
36
51
    if pybaz is None:
37
 
        return OptimisingTestSuite()
 
52
        from unittest import TestSuite
 
53
        return TestSuite()
38
54
    return TestLoader().loadTestsFromName(__name__)
39
55
 
40
56
 
52
68
        os.environ['HOME'] = self._homedir
53
69
 
54
70
        self._archiveroot = os.path.join(self._tmpdir, 'archive')
55
 
        self._archive = pybaz.make_archive('demo@DONOTUSE', str(self._archiveroot))
 
71
        self._archive = make_archive('demo@DONOTUSE', str(self._archiveroot))
56
72
        pybaz.set_my_id("Test User<test@example.org>")
57
73
 
58
74
        self.make_empty_import()
 
75
        self.make_utf8_log()
59
76
 
60
77
        self._empty_tag = 'demo@DONOTUSE/c--empty-tag--0'
61
 
        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0')
 
78
        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0', None)
62
79
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
63
80
            pybaz.Version(self._empty_tag))
64
81
 
65
82
        self._empty_merged_tag = 'demo@DONOTUSE/c--empty-merged-tag--0'
66
83
        self._empty_merged_tag_bzr_base = revision_id(self._empty_merged_tag 
67
 
                                                 + '--base-0')
 
84
                                                 + '--base-0', None)
68
85
        self._empty_merged_tag_bzr = revision_id(self._empty_merged_tag 
69
 
                                                 + '--patch-1')
 
86
                                                 + '--patch-1', None)
70
87
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
71
88
            pybaz.Version(self._empty_merged_tag))
72
89
        tree = pybaz.Revision(self._empty_merged_tag + '--base-0').get(
80
97
        
81
98
        # tree, two commits, includes merge of other branch
82
99
        self._empty_merged_tag_2 = 'demo@DONOTUSE/c--empty-tag-2--0'
83
 
        self._empty_merged_tag_2_bzr_base = revision_id(self._empty_merged_tag_2 + '--base-0')
84
 
        self._empty_merged_tag_2_bzr = revision_id(self._empty_merged_tag_2 + '--patch-1')
 
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)
85
104
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
86
105
            pybaz.Version(self._empty_merged_tag_2))
87
106
        tree = pybaz.Revision(self._empty_merged_tag_2 + '--base-0').get (
93
112
        tree.commit(msg)
94
113
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
95
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
 
96
132
        self.make_import_symlink()
97
133
        self.make_missing_ancestor()
 
134
        self.make_inbranch_continuation()
98
135
 
99
136
    def make_import_symlink(self):
100
137
        self._import_symlink = 'demo@DONOTUSE/c--import-symlink--0'
101
 
        self._import_symlink_bzr = revision_id(self._import_symlink + '--base-0')
 
138
        self._import_symlink_bzr = revision_id(
 
139
            self._import_symlink + '--base-0', None)
102
140
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
103
141
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
104
142
                               self._import_symlink)
105
 
        os.symlink('missing-file-name',
106
 
                   os.path.join(self._tmpdir, 'tree', 'alink'))
 
143
        link_path = os.path.join(self._tmpdir, 'tree', 'alink')
 
144
        os.symlink('missing-file-name', link_path)
107
145
        tree.add_tag('alink')
108
146
        id_file = open(os.path.join(tree, '.arch-ids', 'alink.id'), 'w')
109
147
        id_file.write('symlink_tag\n')
111
149
        msg = tree.log_message()
112
150
        msg["summary"] = "Import with a symlink"
113
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)
114
159
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
115
160
 
116
161
    def make_empty_import(self):
117
162
        self._import = 'demo@DONOTUSE/c--import--0'
118
163
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
119
 
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), self._import)
 
164
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
165
                               self._import)
120
166
        msg = tree.log_message()
121
167
        msg["summary"] = "I am importing now"
122
168
        tree.import_(msg)
123
169
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
124
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
 
125
181
    def make_missing_ancestor(self):
126
182
        self._archivegoneroot = os.path.join(self._tmpdir, 'archivegone')
127
 
        self._archive = pybaz.make_archive('demo-gone@DONOTUSE',
128
 
                                           str(self._archivegoneroot))
 
183
        self._archive = make_archive('demo-gone@DONOTUSE',
 
184
                                     str(self._archivegoneroot))
129
185
        self._missing_import = 'demo-gone@DONOTUSE/c--import--0'
130
186
        self._missing_import_bzr = revision_id(self._missing_import 
131
 
                                                 + '--base-0')
 
187
                                                 + '--base-0', None)
132
188
        self._missing_ancestor = 'demo@DONOTUSE/c--gone--0'
133
189
        self._missing_ancestor_bzr = revision_id(self._missing_ancestor 
134
 
                                                 + '--base-0')
 
190
                                                 + '--base-0', None)
135
191
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
136
192
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
137
193
                               self._missing_import)
142
198
        # tag into the kept archive
143
199
        pybaz.Revision(self._missing_import + '--base-0').make_continuation(
144
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)
145
211
        # and make it inaccessible
146
212
        pybaz.Archive('demo-gone@DONOTUSE').unregister()
147
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
 
148
227
    @classmethod
149
228
    def _makeResource(self):
150
229
        return BazTreeResource()
161
240
    def setUp(self):
162
241
        TestCaseInTempDir.setUp(self)
163
242
        ResourcedTestCase.setUpResources(self)
164
 
        self.output = StringIO()
 
243
        os.environ['HOME'] = self._baz._homedir
165
244
 
166
245
    def tearDown(self):
167
246
        ResourcedTestCase.tearDownResources(self)
168
247
        TestCaseInTempDir.tearDown(self)
169
 
 
170
 
    def collect(self, text):
171
 
        self.output.write(text)
172
 
        self.output.write("\n")
173
 
 
 
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
 
174
263
    def test_import_empty(self):
175
 
        import_version('output', pybaz.Version(self._baz._import), self.collect)
 
264
        import_version('output', pybaz.Version(self._baz._import), None)
176
265
        # expected results:
177
 
        # one commit, no files, revision identifier of 'demo@DONOTUSE_c--import--0--base-0'
 
266
        # one commit, no files, revision identifier of 
 
267
        # 'demo@DONOTUSE_c--import--0--base-0'
178
268
        branch = Branch.open('output')
 
269
        repo = branch.repository
179
270
        self.assertEqual(branch.revision_history(),
180
271
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
181
 
        rev = branch.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
 
272
        rev = repo.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
182
273
        # and again.
183
274
        import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'),
184
 
                       self.collect)
 
275
                       None)
185
276
        branch2 = Branch.open('output2')
 
277
        repo2 = branch2.repository
186
278
        self.assertEqual(branch.revision_history(), branch2.revision_history())
187
 
        rev2 = branch2.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
 
279
        rev2 = repo2.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
188
280
        # they must be the same
189
281
        self.assertEqual(rev, rev2)
190
282
 
195
287
                         "Arch-1:demo@DONOTUSE%c--import--0--base-0")
196
288
 
197
289
    def test_empty_tagged(self):
198
 
        import_version('output', pybaz.Version(self._baz._empty_tag),
199
 
                       self.collect)
 
290
        import_version('output', pybaz.Version(self._baz._empty_tag), None)
200
291
        # expected results:
201
292
        # two commits, no files, revision identifiers of 
202
293
        # 'demo@DONOTUSE_c--import--0--base-0' and
205
296
        self.assertEqual(branch.revision_history(),
206
297
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
207
298
                          self._baz._empty_tag_bzr])
208
 
        rev = branch.get_revision(self._baz._empty_tag_bzr)
 
299
        rev = branch.repository.get_revision(self._baz._empty_tag_bzr)
209
300
        # and again.
210
 
        import_version('output2', pybaz.Version(self._baz._empty_tag),
211
 
                       self.collect)
 
301
        import_version('output2', pybaz.Version(self._baz._empty_tag), None)
212
302
        branch2 = Branch.open('output2')
213
303
        self.assertEqual(branch.revision_history(), branch2.revision_history())
214
 
        rev2 = branch2.get_revision(self._baz._empty_tag_bzr)
 
304
        rev2 = branch2.repository.get_revision(self._baz._empty_tag_bzr)
215
305
        # they must be the same
216
306
        self.assertEqual(rev, rev2)
217
307
 
218
308
        # and we should get some expected values:
219
309
        self.assertEqual(rev.committer, "Test User<test@example.org>")
220
 
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
 
310
        self.assertEqual(rev.message, 
 
311
                         "tag of demo@DONOTUSE/c--import--0--base-0")
221
312
        self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)
222
313
 
223
314
    def test_empty_merged_tagged(self):
224
 
        import_version('output', pybaz.Version(self._baz._empty_merged_tag),
225
 
                       self.collect)
 
315
        import_version('output', pybaz.Version(self._baz._empty_merged_tag), 
 
316
                       None)
226
317
        # expected results:
227
318
        # two commits, no files, revision identifiers of 
228
319
        # 'demo@DONOTUSE_c--import--0--base-0' and
231
322
        # and a merged revision from the latter of
232
323
        # self._baz._empty_tag_bzr
233
324
        branch = Branch.open('output')
 
325
        repo = branch.repository
234
326
        self.assertEqual(branch.revision_history(),
235
327
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
236
328
                          self._baz._empty_merged_tag_bzr_base,
237
329
                          self._baz._empty_merged_tag_bzr])
238
330
        # and again.
239
 
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag),
240
 
                       self.collect)
 
331
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag), 
 
332
                       None)
241
333
        branch2 = Branch.open('output2')
 
334
        repo2 = branch2.repository
242
335
        # and import what we should be merged up against for checking with.
243
 
        import_version('output3', pybaz.Version(self._baz._empty_tag),
244
 
                       self.collect)
 
336
        import_version('output3', pybaz.Version(self._baz._empty_tag), None)
245
337
        branch3 = Branch.open('output3')
246
338
        
247
339
        self.assertEqual(branch.revision_history(), branch2.revision_history())
248
 
        self.assertNotEqual(branch.revision_history(), branch3.revision_history())
 
340
        self.assertNotEqual(branch.revision_history(), 
 
341
                            branch3.revision_history())
249
342
        # check revisions in the history.
250
 
        rev = branch.get_revision(self._baz._empty_merged_tag_bzr_base)
251
 
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_bzr_base)
 
343
        rev = repo.get_revision(self._baz._empty_merged_tag_bzr_base)
 
344
        rev2 = repo2.get_revision(self._baz._empty_merged_tag_bzr_base)
252
345
        # they must be the same
253
346
        self.assertEqual(rev, rev2)
254
347
        # and we should get some expected values:
255
348
        self.assertEqual(rev.committer, "Test User<test@example.org>")
256
 
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
 
349
        self.assertEqual(rev.message, 
 
350
                         "tag of demo@DONOTUSE/c--import--0--base-0")
257
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)
258
354
 
259
355
        # check next revisions in the history.
260
 
        rev = branch.get_revision(self._baz._empty_merged_tag_bzr)
261
 
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_bzr)
 
356
        rev = repo.get_revision(self._baz._empty_merged_tag_bzr)
 
357
        rev2 = repo2.get_revision(self._baz._empty_merged_tag_bzr)
262
358
        # they must be the same
263
359
        self.assertEqual(rev, rev2)
264
360
        # and we should get some expected values:
265
361
        self.assertEqual(rev.committer, "Test User<test@example.org>")
266
362
        self.assertEqual(rev.message, "did a merge, yarh")
267
363
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr)
268
 
        self.assertEqual(rev.parents[0].revision_id,
 
364
        self.assertEqual(rev.parent_ids[0],
269
365
                         self._baz._empty_merged_tag_bzr_base)
270
 
        self.assertEqual(rev.parents[1].revision_id,
271
 
                         self._baz._empty_tag_bzr)
 
366
        self.assertEqual(rev.parent_ids[1], self._baz._empty_tag_bzr)
272
367
 
273
368
        # this tree should have nothing missing from that tree.   
274
369
        # FIXME there is no code for this right now.
275
370
        # self.assertEqual(branch.missing_revisions(branch3), [])
276
371
        
277
372
    def test_merge_branch_with_merges(self):
278
 
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2),
279
 
                       self.collect)
 
373
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2), 
 
374
                       None)
280
375
        # expected results:
281
376
        # two commits, no files, revision identifiers of 
282
377
        # 'demo@DONOTUSE_c--import--0--base-0' and
285
380
        # and a merged revision from the latter of
286
381
        # self._baz._empty_merged_tag_bzr
287
382
        branch = Branch.open('output')
 
383
        repo = branch.repository
288
384
        self.assertEqual(branch.revision_history(),
289
385
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
290
386
                          self._baz._empty_merged_tag_2_bzr_base,
291
387
                          self._baz._empty_merged_tag_2_bzr])
292
388
        # and again.
293
389
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2),
294
 
                       self.collect)
 
390
                       None)
295
391
        branch2 = Branch.open('output2')
 
392
        repo2 = branch2.repository
296
393
        # and import what we should be merged up against for checking with.
297
394
        import_version('output3', pybaz.Version(self._baz._empty_merged_tag),
298
 
                       self.collect)
 
395
                       None)
299
396
        branch3 = Branch.open('output3')
300
397
        
301
398
        self.assertEqual(branch.revision_history(), branch2.revision_history())
302
 
        self.assertNotEqual(branch.revision_history(), branch3.revision_history())
 
399
        self.assertNotEqual(branch.revision_history(), 
 
400
                            branch3.revision_history())
303
401
        # check revisions in the history.
304
 
        rev = branch.get_revision(self._baz._empty_merged_tag_2_bzr_base)
305
 
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_2_bzr_base)
 
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)
306
404
        # they must be the same
307
405
        self.assertEqual(rev, rev2)
308
406
        # and we should get some expected values:
309
407
        self.assertEqual(rev.committer, "Test User<test@example.org>")
310
 
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
311
 
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_2_bzr_base)
 
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)
312
412
 
313
413
        # check next revisions in the history.
314
 
        rev = branch.get_revision(self._baz._empty_merged_tag_2_bzr)
315
 
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_2_bzr)
 
414
        rev = repo.get_revision(self._baz._empty_merged_tag_2_bzr)
 
415
        rev2 = repo2.get_revision(self._baz._empty_merged_tag_2_bzr)
316
416
        # they must be the same
317
417
        self.assertEqual(rev, rev2)
318
418
        # and we should get some expected values:
319
419
        self.assertEqual(rev.committer, "Test User<test@example.org>")
320
420
        self.assertEqual(rev.message, "merge in a merged tree.")
321
421
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_2_bzr)
322
 
        self.assertEqual(rev.parents[0].revision_id,
 
422
        self.assertEqual(rev.parent_ids[0],
323
423
                         self._baz._empty_merged_tag_2_bzr_base)
324
 
        self.assertEqual(rev.parents[1].revision_id,
 
424
        self.assertEqual(rev.parent_ids[1],
325
425
                         self._baz._empty_merged_tag_bzr)
326
426
 
327
427
        # this tree should have nothing missing from that tree.   
329
429
        # self.assertEqual(branch.missing_revisions(branch3), [])
330
430
        
331
431
    def test_import_symlink(self):
332
 
        import_version('output', pybaz.Version(self._baz._import_symlink),
333
 
                       self.collect)
 
432
        import_version('output', pybaz.Version(self._baz._import_symlink), 
 
433
                       None, max_count=1)
334
434
        # expected results:
335
 
        # one commit, no files, revision identifier of 'demo@DONOTUSE_c--import--0--base-0'
 
435
        # two commits, no files, revision identifier of 
 
436
        # 'demo@DONOTUSE_c--import--0--base-0'
336
437
        branch = Branch.open('output')
337
438
        self.assertEqual(branch.revision_history(),
338
439
                         [self._baz._import_symlink_bzr])
339
 
        rev = branch.get_revision(self._baz._import_symlink_bzr)
 
440
        rev = branch.repository.get_revision(self._baz._import_symlink_bzr)
340
441
        # and again.
341
442
        import_version('output2', pybaz.Version(self._baz._import_symlink),
342
 
                       self.collect)
 
443
                       None, max_count=1)
343
444
        branch2 = Branch.open('output2')
344
445
        self.assertEqual(branch.revision_history(), branch2.revision_history())
345
 
        rev2 = branch2.get_revision(self._baz._import_symlink_bzr)
 
446
        rev2 = branch2.repository.get_revision(self._baz._import_symlink_bzr)
346
447
        # they must be the same
347
448
        self.assertEqual(rev, rev2)
348
449
 
352
453
        self.assertEqual(rev.revision_id, self._baz._import_symlink_bzr)
353
454
 
354
455
        # and we want the symlink alink with target 'missing-file-name'
355
 
        inv = branch.get_inventory(rev.inventory_id)
 
456
        inv = branch.repository.get_inventory(rev.revision_id)
356
457
        self.assertEqual(inv.path2id('alink'), 'x_symlink_tag')
357
458
        entry = inv['x_symlink_tag']
358
459
        self.assertEqual(entry.kind, 'symlink')
359
460
        self.assertEqual(entry.symlink_target, 'missing-file-name')
360
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
 
361
466
    def test_missing_ancestor(self):
362
467
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
363
 
                       self.collect)
 
468
                       None)
364
469
        # expected results:
365
470
        # one commits, no files, revision identifiers of 
366
471
        # 'demo@DONOTUSE_c--gone--0--base-0' and
368
473
        branch = Branch.open('output')
369
474
        self.assertEqual(branch.revision_history(),
370
475
                         [self._baz._missing_ancestor_bzr])
371
 
        rev = branch.get_revision(self._baz._missing_ancestor_bzr)
 
476
        rev = branch.repository.get_revision(self._baz._missing_ancestor_bzr)
372
477
        # and again.
373
 
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
374
 
                       self.collect)
 
478
        import_version('output2', pybaz.Version(self._baz._missing_ancestor), 
 
479
                       None)
375
480
        branch2 = Branch.open('output2')
376
481
        self.assertEqual(branch.revision_history(), branch2.revision_history())
377
 
        rev2 = branch2.get_revision(self._baz._missing_ancestor_bzr)
 
482
        rev2 = branch2.repository.get_revision(self._baz._missing_ancestor_bzr)
378
483
        # they must be the same
379
484
        self.assertEqual(rev, rev2)
380
485
 
381
486
        # and we should get some expected values:
382
487
        self.assertEqual(rev.committer, "Test User<test@example.org>")
383
 
        self.assertEqual(rev.message, "tag of demo-gone@DONOTUSE/c--import--0--base-0")
 
488
        self.assertEqual(rev.message, 
 
489
                         "tag of demo-gone@DONOTUSE/c--import--0--base-0")
384
490
        self.assertEqual(rev.revision_id, self._baz._missing_ancestor_bzr)
385
 
        self.assertEqual(rev.parents[0].revision_id,
386
 
                         self._baz._missing_import_bzr)
387
 
        self.assertEqual(1, len(rev.parents))
 
491
        self.assertEqual(rev.parent_ids[0], self._baz._missing_import_bzr)
 
492
        self.assertEqual(1, len(rev.parent_ids))
388
493
 
389
494
        # must NOT be able to get the merged evision
390
 
        self.assertRaises(NoSuchRevision, branch.get_revision, 
 
495
        self.assertRaises(NoSuchRevision, branch.repository.get_revision, 
391
496
                          self._baz._missing_import_bzr)
392
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
 
393
660
 
394
661
class TestNamespacePrevious(TestCase):
395
662
 
420
687
        self.assertEqual(namespace_previous(self.version['versionfix-3000']),
421
688
                         self.version['versionfix-2999'])
422
689
 
 
690
 
423
691
class TestNamespaceMapping(TestCase):
424
692
 
425
693
    def test_namespace_mapping_branch(self):
426
 
        from baz_import import map_namespace
 
694
        from bzrlib.plugins.bzrtools.baz_import import map_namespace
427
695
        branch = pybaz.Branch('foo@example.com/c--b')
428
696
        self.assertRaises(pybaz.errors.NamespaceError, map_namespace, branch)
429
697
        self.assertEqual('c/b', map_namespace(branch['0']))
430
698
        self.assertEqual('c/0.1/b', map_namespace(branch['0.1']))
431
699
 
432
700
    def test_namespace_mapping_no_branch(self):
433
 
        from baz_import import map_namespace
 
701
        from bzrlib.plugins.bzrtools.baz_import import map_namespace
434
702
        category = pybaz.Category('foo@example.com/c')
435
703
        self.assertRaises(pybaz.errors.NamespaceError, map_namespace, category)
436
704
        self.assertEqual('c/+trunk', 
439
707
                         map_namespace(pybaz.Version('%s--0.1' % category)))
440
708
 
441
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
 
442
717
class TestImport(TestCaseInTempDir):
443
718
 
444
719
    def setUp(self):
449
724
        os.mkdir(self._homedir)
450
725
        os.environ['HOME'] = self._homedir
451
726
        self._archiveroot = os.path.join(self._tmpdir, 'archive')
452
 
        self._archive = pybaz.make_archive('demo@DONOTUSE', 
453
 
                                           str(self._archiveroot))
 
727
        self._archive = make_archive('demo@DONOTUSE', str(self._archiveroot))
454
728
 
455
729
    def tearDown(self):
456
730
        os.environ['HOME'] = self._oldhome
460
734
    def make_import(self, namespace):
461
735
        self._import = 'demo@DONOTUSE/%s' % namespace
462
736
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
463
 
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), self._import)
 
737
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
738
                               self._import)
464
739
        msg = tree.log_message()
465
740
        msg["summary"] = "I am importing now"
466
741
        tree.import_(msg)
467
742
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
468
743
 
469
744
    def test_cmd_exists(self):
470
 
        from baz_import import cmd_baz_import
 
745
        from bzrlib.plugins.bzrtools import cmd_baz_import
471
746
 
472
747
    def test_empty_archive(self):
473
748
        command = cmd_baz_import()
474
749
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
475
750
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output')))
476
 
        self.assertEqual(1, 
477
 
                        len(list(os.walk(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)
478
753
 
479
754
    def test_two_branches(self):
480
755
        self.make_import('c--0')
482
757
        command = cmd_baz_import()
483
758
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
484
759
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output')))
485
 
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 'c','+trunk')))
486
 
        self.failUnless(os.path.exists(os.path.join(self._tmpdir,'output', 'c1', '0.2','branch')))
487
 
        self.assertEqual(14, 
488
 
                        len(list(os.walk(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)
489
771
 
490
772
    def test_run_twice(self):
491
773
        self.make_import('c--0')
492
774
        command = cmd_baz_import()
493
775
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
494
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())