← 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-03-01 13:42:15 UTC
  • mfrom: (319 bzrtools)
  • mto: (147.4.30 trunk)
  • mto: This revision was merged to the branch mainline in revision 324.
  • Revision ID: abentley@panoramicfeedback.com-20060301134215-f343b0751787dfb9
Merge push fix

Show diffs side-by-side

added added

removed removed

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