← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to tests/test_baz_import.py

  • Committer: Michael Ellerman
  • Date: 2005-11-28 06:25:38 UTC
  • mto: (0.3.1 shelf-dev) (325.1.2 bzrtools)
  • mto: This revision was merged to the branch mainline in revision 334.
  • Revision ID: michael@ellerman.id.au-20051128062538-a641c1279063c5fc
New shelf layout. Shelves now sit under .bzr/x-shelf/default/

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
26
 
from bzrlib.branch import find_branch
27
 
import shutil
28
 
import tempfile
29
 
from testresources import (TestResource, TestLoader, OptimisingTestSuite,
30
 
                           ResourcedTestCase)
31
 
from fai.cmdutil import namespace_previous
32
 
 
33
 
def test_suite():
34
 
    if pybaz is None:
35
 
        return OptimisingTestSuite()
36
 
    return TestLoader().loadTestsFromName(__name__)
37
 
 
38
 
 
39
 
class BazTreeResource(TestResource):
40
 
 
41
 
    def cleanUp(self):
42
 
        os.environ['HOME'] = self._oldhome
43
 
        shutil.rmtree(self._tmpdir)
44
 
 
45
 
    def __init__(self):
46
 
        self._tmpdir = tempfile.mkdtemp()
47
 
        self._homedir = os.path.join(self._tmpdir, 'home')
48
 
        self._oldhome = os.environ['HOME']
49
 
        os.mkdir(self._homedir)
50
 
        os.environ['HOME'] = self._homedir
51
 
        self._archiveroot = os.path.join(self._tmpdir, 'archive')
52
 
 
53
 
        self._archive = pybaz.make_archive('demo@DONOTUSE', str(self._archiveroot))
54
 
        pybaz.set_my_id("Test User<test@example.org>")
55
 
 
56
 
        self.make_empty_import()
57
 
 
58
 
        self._empty_tag = 'demo@DONOTUSE/c--empty-tag--0'
59
 
        self._empty_tag_bzr = revision_id(self._empty_tag + '--base-0')
60
 
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
61
 
            pybaz.Version(self._empty_tag))
62
 
 
63
 
        self._empty_merged_tag = 'demo@DONOTUSE/c--empty-merged-tag--0'
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')
68
 
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
69
 
            pybaz.Version(self._empty_merged_tag))
70
 
        tree = pybaz.Revision(self._empty_merged_tag + '--base-0').get(
71
 
            os.path.join(self._tmpdir, 'tree'))
72
 
        tree.star_merge(self._empty_tag,
73
 
                        pybaz.Version('demo@DONOTUSE/c--import--0'))
74
 
        msg = tree.log_message()
75
 
        msg["summary"]="did a merge, yarh"
76
 
        tree.commit(msg)
77
 
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
78
 
        
79
 
        # tree, two commits, includes merge of other branch
80
 
        self._empty_merged_tag_2 = 'demo@DONOTUSE/c--empty-tag-2--0'
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')
83
 
        pybaz.Revision('demo@DONOTUSE/c--import--0--base-0').make_continuation(
84
 
            pybaz.Version(self._empty_merged_tag_2))
85
 
        tree = pybaz.Revision(self._empty_merged_tag_2 + '--base-0').get (
86
 
            os.path.join(self._tmpdir, 'tree'))
87
 
        tree.star_merge(self._empty_merged_tag,
88
 
                        pybaz.Version('demo@DONOTUSE/c--import--0'))
89
 
        msg = tree.log_message()
90
 
        msg["summary"] = "merge in a merged tree."
91
 
        tree.commit(msg)
92
 
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
93
 
 
94
 
        self.make_import_symlink()
95
 
 
96
 
    def make_import_symlink(self):
97
 
        self._import_symlink = 'demo@DONOTUSE/c--import-symlink--0'
98
 
        self._import_symlink_bzr = revision_id(self._import_symlink + '--base-0')
99
 
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
100
 
        tree = pybaz.init_tree(os.path.join(self._tmpdir, 'tree'),
101
 
                               self._import_symlink)
102
 
        os.symlink('missing-file-name',
103
 
                   os.path.join(self._tmpdir, 'tree', 'alink'))
104
 
        tree.add_tag('alink')
105
 
        id_file = open(os.path.join(tree, '.arch-ids', 'alink.id'), 'w')
106
 
        id_file.write('symlink_tag\n')
107
 
        id_file.close()
108
 
        msg = tree.log_message()
109
 
        msg["summary"] = "Import with a symlink"
110
 
        tree.import_(msg)
111
 
        shutil.rmtree(os.path.join(self._tmpdir, 'tree'))
112
 
 
113
 
    def make_empty_import(self):
114
 
        self._import = 'demo@DONOTUSE/c--import--0'
115
 
        os.mkdir(os.path.join(self._tmpdir, 'tree'))
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'))
121
 
 
122
 
    @classmethod
123
 
    def _makeResource(self):
124
 
        return BazTreeResource()
125
 
 
126
 
    @classmethod
127
 
    def _cleanResource(self, resource):
128
 
        resource.cleanUp()
129
 
 
130
 
 
131
 
class TestBazImport(TestCaseInTempDir):
132
 
 
133
 
    _resources = [("_baz", BazTreeResource)]
134
 
 
135
 
    def setUp(self):
136
 
        TestCaseInTempDir.setUp(self)
137
 
        ResourcedTestCase.setUpResources(self)
138
 
 
139
 
    def tearDown(self):
140
 
        ResourcedTestCase.tearDownResources(self)
141
 
        TestCaseInTempDir.tearDown(self)
142
 
        
143
 
    def test_import_empty(self):
144
 
        import_version('output', pybaz.Version(self._baz._import))
145
 
        # expected results:
146
 
        # one commit, no files, revision identifier of 'demo@DONOTUSE_c--import--0--base-0'
147
 
        branch = find_branch('output', find_root=False)
148
 
        self.assertEqual(branch.revision_history(),
149
 
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0'])
150
 
        rev = branch.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
151
 
        # and again.
152
 
        import_version('output2', pybaz.Version('demo@DONOTUSE/c--import--0'))
153
 
        branch2 = find_branch('output2', find_root=False)
154
 
        self.assertEqual(branch.revision_history(), branch2.revision_history())
155
 
        rev2 = branch2.get_revision('Arch-1:demo@DONOTUSE%c--import--0--base-0')
156
 
        # they must be the same
157
 
        self.assertEqual(rev, rev2)
158
 
 
159
 
        # and we should get some expected values:
160
 
        self.assertEqual(rev.committer, "Test User<test@example.org>")
161
 
        self.assertEqual(rev.message, "I am importing now")
162
 
        self.assertEqual(rev.revision_id,
163
 
                         "Arch-1:demo@DONOTUSE%c--import--0--base-0")
164
 
 
165
 
    def test_empty_tagged(self):
166
 
        import_version('output', pybaz.Version(self._baz._empty_tag))
167
 
        # expected results:
168
 
        # two commits, no files, revision identifiers of 
169
 
        # 'demo@DONOTUSE_c--import--0--base-0' and
170
 
        # self._baz._empty_tag_bzr
171
 
        branch = find_branch('output', find_root=False)
172
 
        self.assertEqual(branch.revision_history(),
173
 
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
174
 
                          self._baz._empty_tag_bzr])
175
 
        rev = branch.get_revision(self._baz._empty_tag_bzr)
176
 
        # and again.
177
 
        import_version('output2', pybaz.Version(self._baz._empty_tag))
178
 
        branch2 = find_branch('output2', find_root=False)
179
 
        self.assertEqual(branch.revision_history(), branch2.revision_history())
180
 
        rev2 = branch2.get_revision(self._baz._empty_tag_bzr)
181
 
        # they must be the same
182
 
        self.assertEqual(rev, rev2)
183
 
 
184
 
        # and we should get some expected values:
185
 
        self.assertEqual(rev.committer, "Test User<test@example.org>")
186
 
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
187
 
        self.assertEqual(rev.revision_id, self._baz._empty_tag_bzr)
188
 
 
189
 
    def test_empty_merged_tagged(self):
190
 
        import_version('output', pybaz.Version(self._baz._empty_merged_tag))
191
 
        # expected results:
192
 
        # two commits, no files, revision identifiers of 
193
 
        # 'demo@DONOTUSE_c--import--0--base-0' and
194
 
        # self._baz._empty_merged_tag_bzr_base
195
 
        # self._baz._empty_merged_tag_bzr
196
 
        # and a merged revision from the latter of
197
 
        # self._baz._empty_tag_bzr
198
 
        branch = find_branch('output', find_root=False)
199
 
        self.assertEqual(branch.revision_history(),
200
 
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
201
 
                          self._baz._empty_merged_tag_bzr_base,
202
 
                          self._baz._empty_merged_tag_bzr])
203
 
        # and again.
204
 
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag))
205
 
        branch2 = find_branch('output2', find_root=False)
206
 
        # and import what we should be merged up against for checking with.
207
 
        import_version('output3', pybaz.Version(self._baz._empty_tag))
208
 
        branch3 = find_branch('output3', find_root=False)
209
 
        
210
 
        self.assertEqual(branch.revision_history(), branch2.revision_history())
211
 
        self.assertNotEqual(branch.revision_history(), branch3.revision_history())
212
 
        # check revisions in the history.
213
 
        rev = branch.get_revision(self._baz._empty_merged_tag_bzr_base)
214
 
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_bzr_base)
215
 
        # they must be the same
216
 
        self.assertEqual(rev, rev2)
217
 
        # and we should get some expected values:
218
 
        self.assertEqual(rev.committer, "Test User<test@example.org>")
219
 
        self.assertEqual(rev.message, "tag of demo@DONOTUSE/c--import--0--base-0")
220
 
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr_base)
221
 
 
222
 
        # check next revisions in the history.
223
 
        rev = branch.get_revision(self._baz._empty_merged_tag_bzr)
224
 
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_bzr)
225
 
        # they must be the same
226
 
        self.assertEqual(rev, rev2)
227
 
        # and we should get some expected values:
228
 
        self.assertEqual(rev.committer, "Test User<test@example.org>")
229
 
        self.assertEqual(rev.message, "did a merge, yarh")
230
 
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_bzr)
231
 
        self.assertEqual(rev.parents[0].revision_id,
232
 
                         self._baz._empty_merged_tag_bzr_base)
233
 
        self.assertEqual(rev.parents[1].revision_id,
234
 
                         self._baz._empty_tag_bzr)
235
 
 
236
 
        # this tree should have nothing missing from that tree.   
237
 
        # FIXME there is no code for this right now.
238
 
        # self.assertEqual(branch.missing_revisions(branch3), [])
239
 
        
240
 
    def test_merge_branch_with_merges(self):
241
 
        import_version('output', pybaz.Version(self._baz._empty_merged_tag_2))
242
 
        # expected results:
243
 
        # two commits, no files, revision identifiers of 
244
 
        # 'demo@DONOTUSE_c--import--0--base-0' and
245
 
        # self._baz._empty_merged_tag_2_bzr_base
246
 
        # self._baz._empty_merged_tag_2_bzr
247
 
        # and a merged revision from the latter of
248
 
        # self._baz._empty_merged_tag_bzr
249
 
        branch = find_branch('output', find_root=False)
250
 
        self.assertEqual(branch.revision_history(),
251
 
                         ['Arch-1:demo@DONOTUSE%c--import--0--base-0',
252
 
                          self._baz._empty_merged_tag_2_bzr_base,
253
 
                          self._baz._empty_merged_tag_2_bzr])
254
 
        # and again.
255
 
        import_version('output2', pybaz.Version(self._baz._empty_merged_tag_2))
256
 
        branch2 = find_branch('output2', find_root=False)
257
 
        # and import what we should be merged up against for checking with.
258
 
        import_version('output3', pybaz.Version(self._baz._empty_merged_tag))
259
 
        branch3 = find_branch('output3', find_root=False)
260
 
        
261
 
        self.assertEqual(branch.revision_history(), branch2.revision_history())
262
 
        self.assertNotEqual(branch.revision_history(), branch3.revision_history())
263
 
        # check revisions in the history.
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)
266
 
        # they must be the same
267
 
        self.assertEqual(rev, rev2)
268
 
        # and we should get some expected values:
269
 
        self.assertEqual(rev.committer, "Test User<test@example.org>")
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)
272
 
 
273
 
        # check next revisions in the history.
274
 
        rev = branch.get_revision(self._baz._empty_merged_tag_2_bzr)
275
 
        rev2 = branch2.get_revision(self._baz._empty_merged_tag_2_bzr)
276
 
        # they must be the same
277
 
        self.assertEqual(rev, rev2)
278
 
        # and we should get some expected values:
279
 
        self.assertEqual(rev.committer, "Test User<test@example.org>")
280
 
        self.assertEqual(rev.message, "merge in a merged tree.")
281
 
        self.assertEqual(rev.revision_id, self._baz._empty_merged_tag_2_bzr)
282
 
        self.assertEqual(rev.parents[0].revision_id,
283
 
                         self._baz._empty_merged_tag_2_bzr_base)
284
 
        self.assertEqual(rev.parents[1].revision_id,
285
 
                         self._baz._empty_merged_tag_bzr)
286
 
 
287
 
        # this tree should have nothing missing from that tree.   
288
 
        # FIXME there is no code for this right now.
289
 
        # self.assertEqual(branch.missing_revisions(branch3), [])
290
 
        
291
 
    def test_import_symlink(self):
292
 
        import_version('output', pybaz.Version(self._baz._import_symlink))
293
 
        # expected results:
294
 
        # one commit, no files, revision identifier of 'demo@DONOTUSE_c--import--0--base-0'
295
 
        branch = find_branch('output', find_root=False)
296
 
        self.assertEqual(branch.revision_history(),
297
 
                         [self._baz._import_symlink_bzr])
298
 
        rev = branch.get_revision(self._baz._import_symlink_bzr)
299
 
        # and again.
300
 
        import_version('output2', pybaz.Version(self._baz._import_symlink))
301
 
        branch2 = find_branch('output2', find_root=False)
302
 
        self.assertEqual(branch.revision_history(), branch2.revision_history())
303
 
        rev2 = branch2.get_revision(self._baz._import_symlink_bzr)
304
 
        # they must be the same
305
 
        self.assertEqual(rev, rev2)
306
 
 
307
 
        # and we should get some expected values:
308
 
        self.assertEqual(rev.committer, "Test User<test@example.org>")
309
 
        self.assertEqual(rev.message, "Import with a symlink")
310
 
        self.assertEqual(rev.revision_id, self._baz._import_symlink_bzr)
311
 
 
312
 
        # and we want the symlink alink with target 'missing-file-name'
313
 
        inv = branch.get_inventory(rev.inventory_id)
314
 
        self.assertEqual(inv.path2id('alink'), 'x_symlink_tag')
315
 
        entry = inv['x_symlink_tag']
316
 
        self.assertEqual(entry.kind, 'symlink')
317
 
        self.assertEqual(entry.symlink_target, 'missing-file-name')
318
 
 
319
 
 
320
 
class TestNamespacePrevious(TestCase):
321
 
 
322
 
    def setUp(self):
323
 
        TestCase.setUp(self)
324
 
        self.version = pybaz.Version('foo@example.com/c--b--0')
325
 
 
326
 
    def test_base0_none(self):
327
 
        self.assertEqual(namespace_previous(self.version['base-0']), None)
328
 
 
329
 
    def test_patch1_base0(self):
330
 
        self.assertEqual(namespace_previous(self.version['patch-1']),
331
 
                         self.version['base-0'])
332
 
        
333
 
    def test_patch3000_patch2999(self):
334
 
        self.assertEqual(namespace_previous(self.version['patch-3000']),
335
 
                         self.version['patch-2999'])
336
 
        
337
 
    def test_version0_raises(self):
338
 
        self.assertRaises(RuntimeError, namespace_previous,
339
 
                          self.version['version-0'])
340
 
 
341
 
    def test_version1_version0(self):
342
 
        self.assertEqual(namespace_previous(self.version['version-1']),
343
 
                         self.version['version-0'])