← 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-28 05:43:19 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-20050928054319-2c2e9e3048bbc215
find_branch -> open_containing change

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test_baz_import.py
 
1
# Copyright (C) 2005 Canonical Limited
 
2
#   Authors: Robert Collins <robert.collins@canonical.com>
 
3
#
 
4
#    This program is free software; you can redistribute it and/or modify
 
5
#    it under the terms of the GNU General Public License as published by
 
6
#    the Free Software Foundation; either version 2 of the License, or
 
7
#    (at your option) any later version.
 
8
#
 
9
#    This program is distributed in the hope that it will be useful,
 
10
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
12
#    GNU General Public License for more details.
 
13
#
 
14
#    You should have received a copy of the GNU General Public License
 
15
#    along with this program; if not, write to the Free Software
 
16
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
17
 
 
18
from bzrlib.selftest import TestCaseInTempDir, TestCase
 
19
from bzrlib.selftest.blackbox import has_symlinks
 
20
try:
 
21
    import pybaz
 
22
except ImportError:
 
23
    pybaz = None
 
24
import os
 
25
from baz_import import import_version, revision_id, cmd_baz_import
 
26
from bzrlib.branch import find_branch
 
27
from bzrlib.errors import NoSuchRevision
 
28
import shutil
 
29
from StringIO import StringIO
 
30
import tempfile
 
31
from testresources import (TestResource, TestLoader, OptimisingTestSuite,
 
32
                           ResourcedTestCase)
 
33
from fai import namespace_previous
 
34
 
 
35
def test_suite():
 
36
    if pybaz is None:
 
37
        return OptimisingTestSuite()
 
38
    return TestLoader().loadTestsFromName(__name__)
 
39
 
 
40
 
 
41
class BazTreeResource(TestResource):
 
42
 
 
43
    def cleanUp(self):
 
44
        os.environ['HOME'] = self._oldhome
 
45
        shutil.rmtree(self._tmpdir)
 
46
 
 
47
    def __init__(self):
 
48
        self._tmpdir = tempfile.mkdtemp()
 
49
        self._homedir = os.path.join(self._tmpdir, 'home')
 
50
        self._oldhome = os.environ['HOME']
 
51
        os.mkdir(self._homedir)
 
52
        os.environ['HOME'] = self._homedir
 
53
 
 
54
        self._archiveroot = os.path.join(self._tmpdir, 'archive')
 
55
        self._archive = pybaz.make_archive('demo@DONOTUSE', str(self._archiveroot))
 
56
        pybaz.set_my_id("Test User<test@example.org>")
 
57
 
 
58
        self.make_empty_import()
 
59
 
 
60
        self._empty_tag = 'demo@DONOTUSE/c--empty-tag--0'
 
61
        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0')
 
62
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
 
63
            pybaz.Version(self._empty_tag))
 
64
 
 
65
        self._empty_merged_tag = 'demo@DONOTUSE/c--empty-merged-tag--0'
 
66
        self._empty_merged_tag_bzr_base = revision_id(self._empty_merged_tag 
 
67
                                                 + '--base-0')
 
68
        self._empty_merged_tag_bzr = revision_id(self._empty_merged_tag 
 
69
                                                 + '--patch-1')
 
70
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
 
71
            pybaz.Version(self._empty_merged_tag))
 
72
        tree = pybaz.Revision(self._empty_merged_tag + '--base-0').get(
 
73
            os.path.join(self._tmpdir, 'tree'))
 
74
        tree.star_merge(self._empty_tag,
 
75
                        pybaz.Version('demo@DONOTUSE/c--import--0'))
 
76
        msg = tree.log_message()
 
77
        msg["summary"]="did a merge, yarh"
 
78
        tree.commit(msg)
 
79
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
 
80
        
 
81
        # tree, two commits, includes merge of other branch
 
82
        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')
 
85
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
 
86
            pybaz.Version(self._empty_merged_tag_2))
 
87
        tree = pybaz.Revision(self._empty_merged_tag_2 + '--base-0').get (
 
88
            os.path.join(self._tmpdir, 'tree'))
 
89
        tree.star_merge(self._empty_merged_tag,
 
90
                        pybaz.Version('demo@DONOTUSE/c--import--0'))
 
91
        msg = tree.log_message()
 
92
        msg["summary"] = "merge in a merged tree."
 
93
        tree.commit(msg)
 
94
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
 
95
 
 
96
        self.make_import_symlink()
 
97
        self.make_missing_ancestor()
 
98
 
 
99
    def make_import_symlink(self):
 
100
        self._import_symlink = 'demo@DONOTUSE/c--import-symlink--0'
 
101
        self._import_symlink_bzr = revision_id(self._import_symlink + '--base-0')
 
102
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
 
103
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
 
104
                               self._import_symlink)
 
105
        os.symlink('missing-file-name',
 
106
                   os.path.join(self._tmpdir, 'tree', 'alink'))
 
107
        tree.add_tag('alink')
 
108
        id_file = open(os.path.join(tree, '.arch-ids', 'alink.id'), 'w')
 
109
        id_file.write('symlink_tag\n')
 
110
        id_file.close()
 
111
        msg = tree.log_message()
 
112
        msg["summary"] = "Import with a symlink"
 
113
        tree.import_(msg)
 
114
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
 
115
 
 
116
    def make_empty_import(self):
 
117
        self._import = 'demo@DONOTUSE/c--import--0'
 
118
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
 
119
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), self._import)
 
120
        msg = tree.log_message()
 
121
        msg["summary"] = "I am importing now"
 
122
        tree.import_(msg)
 
123
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
 
124
 
 
125
    def make_missing_ancestor(self):
 
126
        self._archivegoneroot = os.path.join(self._tmpdir, 'archivegone')
 
127
        self._archive = pybaz.make_archive('demo-gone@DONOTUSE',
 
128
                                           str(self._archivegoneroot))
 
129
        self._missing_import = 'demo-gone@DONOTUSE/c--import--0'
 
130
        self._missing_import_bzr = revision_id(self._missing_import 
 
131
                                                 + '--base-0')
 
132
        self._missing_ancestor = 'demo@DONOTUSE/c--gone--0'
 
133
        self._missing_ancestor_bzr = revision_id(self._missing_ancestor 
 
134
                                                 + '--base-0')
 
135
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
 
136
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), 
 
137
                               self._missing_import)
 
138
        msg = tree.log_message()
 
139
        msg["summary"] = "I am importing now"
 
140
        tree.import_(msg)
 
141
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
 
142
        # tag into the kept archive
 
143
        pybaz.Revision(self._missing_import + '--base-0').make_continuation(
 
144
            pybaz.Version(self._missing_ancestor))
 
145
        # and make it inaccessible
 
146
        pybaz.Archive('demo-gone@DONOTUSE').unregister()
 
147
 
 
148
    @classmethod
 
149
    def _makeResource(self):
 
150
        return BazTreeResource()
 
151
 
 
152
    @classmethod
 
153
    def _cleanResource(self, resource):
 
154
        resource.cleanUp()
 
155
 
 
156
 
 
157
class TestImportBranch(TestCaseInTempDir):
 
158
 
 
159
    _resources = [("_baz", BazTreeResource)]
 
160
 
 
161
    def setUp(self):
 
162
        TestCaseInTempDir.setUp(self)
 
163
        ResourcedTestCase.setUpResources(self)
 
164
        self.output = StringIO()
 
165
 
 
166
    def tearDown(self):
 
167
        ResourcedTestCase.tearDownResources(self)
 
168
        TestCaseInTempDir.tearDown(self)
 
169
 
 
170
    def collect(self, text):
 
171
        self.output.write(text)
 
172
        self.output.write("\n")
 
173
 
 
174
    def test_import_empty(self):
 
175
        import_version('output', pybaz.Version(self._baz._import), self.collect)
 
176
        # expected results:
 
177
        # one commit, no files, revision identifier of 'demo@DONOTUSE_c--import--0--base-0'
 
178
        branch = find_branch('output', find_root=False)
 
179
        self.assertEqual(branch.revision_history(),
 
180
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
 
181
        rev = branch.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
 
182
        # and again.
 
183
        import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'),
 
184
                       self.collect)
 
185
        branch2 = find_branch('output2', find_root=False)
 
186
        self.assertEqual(branch.revision_history(), branch2.revision_history())
 
187
        rev2 = branch2.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
 
188
        # they must be the same
 
189
        self.assertEqual(rev, rev2)
 
190
 
 
191
        # and we should get some expected values:
 
192
        self.assertEqual(rev.committer, "Test User<test@example.org>")
 
193
        self.assertEqual(rev.message, "I am importing now")
 
194
        self.assertEqual(rev.revision_id,
 
195
                         "Arch-1:demo@DONOTUSE%c--import--0--base-0")
 
196
 
 
197
    def test_empty_tagged(self):
 
198
        import_version('output', pybaz.Version(self._baz._empty_tag),
 
199
                       self.collect)
 
200
        # expected results:
 
201
        # two commits, no files, revision identifiers of 
 
202
        # 'demo@DONOTUSE_c--import--0--base-0' and
 
203
        # self._baz._empty_tag_bzr
 
204
        branch = find_branch('output', find_root=False)
 
205
        self.assertEqual(branch.revision_history(),
 
206
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
 
207
                          self._baz._empty_tag_bzr])
 
208
        rev = branch.get_revision(self._baz._empty_tag_bzr)
 
209
        # and again.
 
210
        import_version('output2', pybaz.Version(self._baz._empty_tag),
 
211
                       self.collect)
 
212
        branch2 = find_branch('output2', find_root=False)
 
213
        self.assertEqual(branch.revision_history(), branch2.revision_history())
 
214
        rev2 = branch2.get_revision(self._baz._empty_tag_bzr)
 
215
        # they must be the same
 
216
        self.assertEqual(rev, rev2)
 
217
 
 
218
        # and we should get some expected values:
 
219
        self.assertEqual(rev.committer, "Test User<test@example.org>")
 
220
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
 
221
        self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)
 
222
 
 
223
    def test_empty_merged_tagged(self):
 
224
        import_version('output', pybaz.Version(self._baz._empty_merged_tag),
 
225
                       self.collect)
 
226
        # expected results:
 
227
        # two commits, no files, revision identifiers of 
 
228
        # 'demo@DONOTUSE_c--import--0--base-0' and
 
229
        # self._baz._empty_merged_tag_bzr_base
 
230
        # self._baz._empty_merged_tag_bzr
 
231
        # and a merged revision from the latter of
 
232
        # self._baz._empty_tag_bzr
 
233
        branch = find_branch('output', find_root=False)
 
234
        self.assertEqual(branch.revision_history(),
 
235
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
 
236
                          self._baz._empty_merged_tag_bzr_base,
 
237
                          self._baz._empty_merged_tag_bzr])
 
238
        # and again.
 
239
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag),
 
240
                       self.collect)
 
241
        branch2 = find_branch('output2', find_root=False)
 
242
        # 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)
 
245
        branch3 = find_branch('output3', find_root=False)
 
246
        
 
247
        self.assertEqual(branch.revision_history(), branch2.revision_history())
 
248
        self.assertNotEqual(branch.revision_history(), branch3.revision_history())
 
249
        # 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)
 
252
        # they must be the same
 
253
        self.assertEqual(rev, rev2)
 
254
        # and we should get some expected values:
 
255
        self.assertEqual(rev.committer, "Test User<test@example.org>")
 
256
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
 
257
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr_base)
 
258
 
 
259
        # 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)
 
262
        # they must be the same
 
263
        self.assertEqual(rev, rev2)
 
264
        # and we should get some expected values:
 
265
        self.assertEqual(rev.committer, "Test User<test@example.org>")
 
266
        self.assertEqual(rev.message, "did a merge, yarh")
 
267
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr)
 
268
        self.assertEqual(rev.parents[0].revision_id,
 
269
                         self._baz._empty_merged_tag_bzr_base)
 
270
        self.assertEqual(rev.parents[1].revision_id,
 
271
                         self._baz._empty_tag_bzr)
 
272
 
 
273
        # this tree should have nothing missing from that tree.   
 
274
        # FIXME there is no code for this right now.
 
275
        # self.assertEqual(branch.missing_revisions(branch3), [])
 
276
        
 
277
    def test_merge_branch_with_merges(self):
 
278
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2),
 
279
                       self.collect)
 
280
        # expected results:
 
281
        # two commits, no files, revision identifiers of 
 
282
        # 'demo@DONOTUSE_c--import--0--base-0' and
 
283
        # self._baz._empty_merged_tag_2_bzr_base
 
284
        # self._baz._empty_merged_tag_2_bzr
 
285
        # and a merged revision from the latter of
 
286
        # self._baz._empty_merged_tag_bzr
 
287
        branch = find_branch('output', find_root=False)
 
288
        self.assertEqual(branch.revision_history(),
 
289
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
 
290
                          self._baz._empty_merged_tag_2_bzr_base,
 
291
                          self._baz._empty_merged_tag_2_bzr])
 
292
        # and again.
 
293
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2),
 
294
                       self.collect)
 
295
        branch2 = find_branch('output2', find_root=False)
 
296
        # and import what we should be merged up against for checking with.
 
297
        import_version('output3', pybaz.Version(self._baz._empty_merged_tag),
 
298
                       self.collect)
 
299
        branch3 = find_branch('output3', find_root=False)
 
300
        
 
301
        self.assertEqual(branch.revision_history(), branch2.revision_history())
 
302
        self.assertNotEqual(branch.revision_history(), branch3.revision_history())
 
303
        # 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)
 
306
        # they must be the same
 
307
        self.assertEqual(rev, rev2)
 
308
        # and we should get some expected values:
 
309
        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)
 
312
 
 
313
        # 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)
 
316
        # they must be the same
 
317
        self.assertEqual(rev, rev2)
 
318
        # and we should get some expected values:
 
319
        self.assertEqual(rev.committer, "Test User<test@example.org>")
 
320
        self.assertEqual(rev.message, "merge in a merged tree.")
 
321
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_2_bzr)
 
322
        self.assertEqual(rev.parents[0].revision_id,
 
323
                         self._baz._empty_merged_tag_2_bzr_base)
 
324
        self.assertEqual(rev.parents[1].revision_id,
 
325
                         self._baz._empty_merged_tag_bzr)
 
326
 
 
327
        # this tree should have nothing missing from that tree.   
 
328
        # FIXME there is no code for this right now.
 
329
        # self.assertEqual(branch.missing_revisions(branch3), [])
 
330
        
 
331
    def test_import_symlink(self):
 
332
        import_version('output', pybaz.Version(self._baz._import_symlink),
 
333
                       self.collect)
 
334
        # expected results:
 
335
        # one commit, no files, revision identifier of 'demo@DONOTUSE_c--import--0--base-0'
 
336
        branch = find_branch('output', find_root=False)
 
337
        self.assertEqual(branch.revision_history(),
 
338
                         [self._baz._import_symlink_bzr])
 
339
        rev = branch.get_revision(self._baz._import_symlink_bzr)
 
340
        # and again.
 
341
        import_version('output2', pybaz.Version(self._baz._import_symlink),
 
342
                       self.collect)
 
343
        branch2 = find_branch('output2', find_root=False)
 
344
        self.assertEqual(branch.revision_history(), branch2.revision_history())
 
345
        rev2 = branch2.get_revision(self._baz._import_symlink_bzr)
 
346
        # they must be the same
 
347
        self.assertEqual(rev, rev2)
 
348
 
 
349
        # and we should get some expected values:
 
350
        self.assertEqual(rev.committer, "Test User<test@example.org>")
 
351
        self.assertEqual(rev.message, "Import with a symlink")
 
352
        self.assertEqual(rev.revision_id, self._baz._import_symlink_bzr)
 
353
 
 
354
        # and we want the symlink alink with target 'missing-file-name'
 
355
        inv = branch.get_inventory(rev.inventory_id)
 
356
        self.assertEqual(inv.path2id('alink'), 'x_symlink_tag')
 
357
        entry = inv['x_symlink_tag']
 
358
        self.assertEqual(entry.kind, 'symlink')
 
359
        self.assertEqual(entry.symlink_target, 'missing-file-name')
 
360
 
 
361
    def test_missing_ancestor(self):
 
362
        import_version('output', pybaz.Version(self._baz._missing_ancestor),
 
363
                       self.collect)
 
364
        # expected results:
 
365
        # one commits, no files, revision identifiers of 
 
366
        # 'demo@DONOTUSE_c--gone--0--base-0' and
 
367
        # a merge of demo-gone@DONOTUSE%c--import--0
 
368
        branch = find_branch('output', find_root=False)
 
369
        self.assertEqual(branch.revision_history(),
 
370
                         [self._baz._missing_ancestor_bzr])
 
371
        rev = branch.get_revision(self._baz._missing_ancestor_bzr)
 
372
        # and again.
 
373
        import_version('output2', pybaz.Version(self._baz._missing_ancestor),
 
374
                       self.collect)
 
375
        branch2 = find_branch('output2', find_root=False)
 
376
        self.assertEqual(branch.revision_history(), branch2.revision_history())
 
377
        rev2 = branch2.get_revision(self._baz._missing_ancestor_bzr)
 
378
        # they must be the same
 
379
        self.assertEqual(rev, rev2)
 
380
 
 
381
        # and we should get some expected values:
 
382
        self.assertEqual(rev.committer, "Test User<test@example.org>")
 
383
        self.assertEqual(rev.message, "tag of demo-gone@DONOTUSE/c--import--0--base-0")
 
384
        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))
 
388
 
 
389
        # must NOT be able to get the merged evision
 
390
        self.assertRaises(NoSuchRevision, branch.get_revision, 
 
391
                          self._baz._missing_import_bzr)
 
392
 
 
393
 
 
394
class TestNamespacePrevious(TestCase):
 
395
 
 
396
    def setUp(self):
 
397
        TestCase.setUp(self)
 
398
        self.version = pybaz.Version('foo@example.com/c--b--0')
 
399
 
 
400
    def test_base0_none(self):
 
401
        self.assertEqual(namespace_previous(self.version['base-0']), None)
 
402
 
 
403
    def test_patch1_base0(self):
 
404
        self.assertEqual(namespace_previous(self.version['patch-1']),
 
405
                         self.version['base-0'])
 
406
        
 
407
    def test_patch3000_patch2999(self):
 
408
        self.assertEqual(namespace_previous(self.version['patch-3000']),
 
409
                         self.version['patch-2999'])
 
410
        
 
411
    def test_version0_raises(self):
 
412
        self.assertRaises(RuntimeError, namespace_previous,
 
413
                          self.version['version-0'])
 
414
 
 
415
    def test_version1_version0(self):
 
416
        self.assertEqual(namespace_previous(self.version['version-1']),
 
417
                         self.version['version-0'])
 
418
 
 
419
    def test_version3000_patch2999(self):
 
420
        self.assertEqual(namespace_previous(self.version['version-3000']),
 
421
                         self.version['version-2999'])
 
422
 
 
423
class TestNamespaceMapping(TestCase):
 
424
 
 
425
    def test_namespace_mapping_branch(self):
 
426
        from baz_import import map_namespace
 
427
        branch = pybaz.Branch('foo@example.com/c--b')
 
428
        self.assertRaises(pybaz.errors.NamespaceError, map_namespace, branch)
 
429
        self.assertEqual('c/b', map_namespace(branch['0']))
 
430
        self.assertEqual('c/0.1/b', map_namespace(branch['0.1']))
 
431
 
 
432
    def test_namespace_mapping_no_branch(self):
 
433
        from baz_import import map_namespace
 
434
        category = pybaz.Category('foo@example.com/c')
 
435
        self.assertRaises(pybaz.errors.NamespaceError, map_namespace, category)
 
436
        self.assertEqual('c/+trunk', 
 
437
                         map_namespace(pybaz.Version("%s--0" % category)))
 
438
        self.assertEqual('c/0.1/+trunk',
 
439
                         map_namespace(pybaz.Version('%s--0.1' % category)))
 
440
 
 
441
 
 
442
class TestImport(TestCaseInTempDir):
 
443
 
 
444
    def setUp(self):
 
445
        TestCaseInTempDir.setUp(self)
 
446
        self._oldhome = os.environ['HOME']
 
447
        self._tmpdir = tempfile.mkdtemp()
 
448
        self._homedir = os.path.join(self._tmpdir, 'home')
 
449
        os.mkdir(self._homedir)
 
450
        os.environ['HOME'] = self._homedir
 
451
        self._archiveroot = os.path.join(self._tmpdir, 'archive')
 
452
        self._archive = pybaz.make_archive('demo@DONOTUSE', 
 
453
                                           str(self._archiveroot))
 
454
 
 
455
    def tearDown(self):
 
456
        os.environ['HOME'] = self._oldhome
 
457
        shutil.rmtree(self._tmpdir)
 
458
        TestCaseInTempDir.tearDown(self)
 
459
 
 
460
    def make_import(self, namespace):
 
461
        self._import = 'demo@DONOTUSE/%s' % namespace
 
462
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
 
463
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'), self._import)
 
464
        msg = tree.log_message()
 
465
        msg["summary"] = "I am importing now"
 
466
        tree.import_(msg)
 
467
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
 
468
 
 
469
    def test_cmd_exists(self):
 
470
        from baz_import import cmd_baz_import
 
471
 
 
472
    def test_empty_archive(self):
 
473
        command = cmd_baz_import()
 
474
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
 
475
        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')))))
 
478
 
 
479
    def test_two_branches(self):
 
480
        self.make_import('c--0')
 
481
        self.make_import('c1--branch--0.2')
 
482
        command = cmd_baz_import()
 
483
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
 
484
        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')))))
 
489
 
 
490
    def test_run_twice(self):
 
491
        self.make_import('c--0')
 
492
        command = cmd_baz_import()
 
493
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')
 
494
        command.run(os.path.join(self._tmpdir, 'output'), 'demo@DONOTUSE')