← 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 12:39:26 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-20050913123926-b72242bdacc1ae52
create the output directory

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