/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_version_info.py

  • Committer: John Arbash Meinel
  • Date: 2009-12-22 16:28:47 UTC
  • mto: This revision was merged to the branch mainline in revision 4922.
  • Revision ID: john@arbash-meinel.com-20091222162847-tvnsc69to4l4uf5r
Implement a permute_for_extension helper.

Use it for all of the 'simple' extension permutations.
It basically permutes all tests in the current module, by setting TestCase.module.
Which works well for most of our extension tests. Some had more advanced
handling of permutations (extra permutations, custom vars, etc.)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_version_info.py
 
1
# Copyright (C) 2005, 2006 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Tests for version_info"""
 
18
 
 
19
from cStringIO import StringIO
 
20
import imp
 
21
import os
 
22
import sys
 
23
 
 
24
from bzrlib import (
 
25
    errors,
 
26
    symbol_versioning,
 
27
    tests,
 
28
    version_info_formats,
 
29
    )
 
30
from bzrlib.tests import TestCaseWithTransport
 
31
from bzrlib.rio import read_stanzas
 
32
 
 
33
from bzrlib.version_info_formats.format_custom import CustomVersionInfoBuilder
 
34
from bzrlib.version_info_formats.format_rio import RioVersionInfoBuilder
 
35
from bzrlib.version_info_formats.format_python import PythonVersionInfoBuilder
 
36
 
 
37
 
 
38
class TestVersionInfo(TestCaseWithTransport):
 
39
 
 
40
    def create_branch(self):
 
41
        wt = self.make_branch_and_tree('branch')
 
42
 
 
43
        self.build_tree(['branch/a'])
 
44
        wt.add('a')
 
45
        wt.commit('a', rev_id='r1')
 
46
 
 
47
        self.build_tree(['branch/b'])
 
48
        wt.add('b')
 
49
        wt.commit('b', rev_id='r2')
 
50
 
 
51
        self.build_tree_contents([('branch/a', 'new contents\n')])
 
52
        wt.commit(u'\xe52', rev_id='r3')
 
53
 
 
54
        return wt
 
55
 
 
56
    def test_rio_null(self):
 
57
        wt = self.make_branch_and_tree('branch')
 
58
 
 
59
        sio = StringIO()
 
60
        builder = RioVersionInfoBuilder(wt.branch, working_tree=wt)
 
61
        builder.generate(sio)
 
62
        val = sio.getvalue()
 
63
        self.assertContainsRe(val, 'build-date:')
 
64
        self.assertContainsRe(val, 'revno: 0')
 
65
 
 
66
    def test_rio_version_text(self):
 
67
        wt = self.create_branch()
 
68
 
 
69
        def regen(**kwargs):
 
70
            sio = StringIO()
 
71
            builder = RioVersionInfoBuilder(wt.branch, working_tree=wt,
 
72
                                            **kwargs)
 
73
            builder.generate(sio)
 
74
            val = sio.getvalue()
 
75
            return val
 
76
 
 
77
        val = regen()
 
78
        self.assertContainsRe(val, 'build-date:')
 
79
        self.assertContainsRe(val, 'date:')
 
80
        self.assertContainsRe(val, 'revno: 3')
 
81
        self.assertContainsRe(val, 'revision-id: r3')
 
82
 
 
83
        val = regen(check_for_clean=True)
 
84
        self.assertContainsRe(val, 'clean: True')
 
85
 
 
86
        self.build_tree(['branch/c'])
 
87
        val = regen(check_for_clean=True)
 
88
        self.assertContainsRe(val, 'clean: False')
 
89
        os.remove('branch/c')
 
90
 
 
91
        val = regen(include_revision_history=True)
 
92
        self.assertContainsRe(val, 'id: r1')
 
93
        self.assertContainsRe(val, 'message: a')
 
94
        self.assertContainsRe(val, 'id: r2')
 
95
        self.assertContainsRe(val, 'message: b')
 
96
        self.assertContainsRe(val, 'id: r3')
 
97
        self.assertContainsRe(val, 'message: \xc3\xa52') # utf8 encoding '\xe5'
 
98
 
 
99
    def test_rio_version_hook(self):
 
100
        def update_stanza(rev, stanza):
 
101
            stanza.add('bla', 'bloe')
 
102
        RioVersionInfoBuilder.hooks.install_named_hook(
 
103
            'revision', update_stanza, None)
 
104
        wt = self.create_branch()
 
105
 
 
106
        def regen(**kwargs):
 
107
            sio = StringIO()
 
108
            builder = RioVersionInfoBuilder(wt.branch, working_tree=wt,
 
109
                                            **kwargs)
 
110
            builder.generate(sio)
 
111
            sio.seek(0)
 
112
            stanzas = list(read_stanzas(sio))
 
113
            self.assertEqual(1, len(stanzas))
 
114
            return stanzas[0]
 
115
 
 
116
        stanza = regen()
 
117
        self.assertEqual(['bloe'], stanza.get_all('bla'))
 
118
 
 
119
    def test_rio_version(self):
 
120
        wt = self.create_branch()
 
121
 
 
122
        def regen(**kwargs):
 
123
            sio = StringIO()
 
124
            builder = RioVersionInfoBuilder(wt.branch, working_tree=wt,
 
125
                                            **kwargs)
 
126
            builder.generate(sio)
 
127
            sio.seek(0)
 
128
            stanzas = list(read_stanzas(sio))
 
129
            self.assertEqual(1, len(stanzas))
 
130
            return stanzas[0]
 
131
 
 
132
        def get_one_stanza(stanza, key):
 
133
            new_stanzas = list(read_stanzas(
 
134
                                StringIO(stanza[key].encode('utf8'))))
 
135
            self.assertEqual(1, len(new_stanzas))
 
136
            return new_stanzas[0]
 
137
 
 
138
        stanza = regen()
 
139
        self.failUnless('date' in stanza)
 
140
        self.failUnless('build-date' in stanza)
 
141
        self.assertEqual(['3'], stanza.get_all('revno'))
 
142
        self.assertEqual(['r3'], stanza.get_all('revision-id'))
 
143
 
 
144
        stanza = regen(check_for_clean=True)
 
145
        self.assertEqual(['True'], stanza.get_all('clean'))
 
146
 
 
147
        self.build_tree(['branch/c'])
 
148
        stanza = regen(check_for_clean=True, include_file_revisions=True)
 
149
        self.assertEqual(['False'], stanza.get_all('clean'))
 
150
 
 
151
        # This assumes it's being run against a tree that does not update the
 
152
        # root revision on every commit.
 
153
        file_rev_stanza = get_one_stanza(stanza, 'file-revisions')
 
154
        self.assertEqual(['', 'a', 'b', 'c'], file_rev_stanza.get_all('path'))
 
155
        self.assertEqual(['r1', 'r3', 'r2', 'unversioned'],
 
156
            file_rev_stanza.get_all('revision'))
 
157
        os.remove('branch/c')
 
158
 
 
159
        stanza = regen(include_revision_history=True)
 
160
        revision_stanza = get_one_stanza(stanza, 'revisions')
 
161
        self.assertEqual(['r1', 'r2', 'r3'], revision_stanza.get_all('id'))
 
162
        self.assertEqual(['a', 'b', u'\xe52'], revision_stanza.get_all('message'))
 
163
        self.assertEqual(3, len(revision_stanza.get_all('date')))
 
164
 
 
165
        # a was modified, so it should show up modified again
 
166
        self.build_tree(['branch/a', 'branch/c'])
 
167
        wt.add('c')
 
168
        wt.rename_one('b', 'd')
 
169
        stanza = regen(check_for_clean=True, include_file_revisions=True)
 
170
        file_rev_stanza = get_one_stanza(stanza, 'file-revisions')
 
171
        self.assertEqual(['', 'a', 'b', 'c', 'd'],
 
172
                          file_rev_stanza.get_all('path'))
 
173
        self.assertEqual(['r1', 'modified', 'renamed to d', 'new',
 
174
                          'renamed from b'],
 
175
                         file_rev_stanza.get_all('revision'))
 
176
 
 
177
        wt.commit('modified', rev_id='r4')
 
178
        wt.remove(['c', 'd'])
 
179
        os.remove('branch/d')
 
180
        stanza = regen(check_for_clean=True, include_file_revisions=True)
 
181
        file_rev_stanza = get_one_stanza(stanza, 'file-revisions')
 
182
        self.assertEqual(['', 'a', 'c', 'd'], file_rev_stanza.get_all('path'))
 
183
        self.assertEqual(['r1', 'r4', 'unversioned', 'removed'],
 
184
                         file_rev_stanza.get_all('revision'))
 
185
 
 
186
    def test_python_null(self):
 
187
        wt = self.make_branch_and_tree('branch')
 
188
 
 
189
        sio = StringIO()
 
190
        builder = PythonVersionInfoBuilder(wt.branch, working_tree=wt)
 
191
        builder.generate(sio)
 
192
        val = sio.getvalue()
 
193
        self.assertContainsRe(val, "'revision_id': None")
 
194
        self.assertContainsRe(val, "'revno': 0")
 
195
 
 
196
    def test_python_version(self):
 
197
        wt = self.create_branch()
 
198
 
 
199
        def regen(**kwargs):
 
200
            """Create a test module, import and return it"""
 
201
            outf = open('test_version_information.py', 'wb')
 
202
            try:
 
203
                builder = PythonVersionInfoBuilder(wt.branch, working_tree=wt,
 
204
                                                   **kwargs)
 
205
                builder.generate(outf)
 
206
            finally:
 
207
                outf.close()
 
208
            module_info = imp.find_module('test_version_information',
 
209
                                          [os.getcwdu()])
 
210
            tvi = imp.load_module('tvi', *module_info)
 
211
            # Make sure the module isn't cached
 
212
            sys.modules.pop('tvi', None)
 
213
            sys.modules.pop('test_version_information', None)
 
214
            # Delete the compiled versions, because we are generating
 
215
            # a new file fast enough that python doesn't detect it
 
216
            # needs to recompile, and using sleep() just makes the
 
217
            # test slow
 
218
            if os.path.exists('test_version_information.pyc'):
 
219
                os.remove('test_version_information.pyc')
 
220
            if os.path.exists('test_version_information.pyo'):
 
221
                os.remove('test_version_information.pyo')
 
222
            return tvi
 
223
 
 
224
        tvi = regen()
 
225
        self.assertEqual(3, tvi.version_info['revno'])
 
226
        self.assertEqual('r3', tvi.version_info['revision_id'])
 
227
        self.failUnless(tvi.version_info.has_key('date'))
 
228
        self.assertEqual(None, tvi.version_info['clean'])
 
229
 
 
230
        tvi = regen(check_for_clean=True)
 
231
        self.assertEqual(True, tvi.version_info['clean'])
 
232
 
 
233
        self.build_tree(['branch/c'])
 
234
        tvi = regen(check_for_clean=True, include_file_revisions=True)
 
235
        self.assertEqual(False, tvi.version_info['clean'])
 
236
        self.assertEqual(['', 'a', 'b', 'c'],
 
237
                         sorted(tvi.file_revisions.keys()))
 
238
        self.assertEqual('r3', tvi.file_revisions['a'])
 
239
        self.assertEqual('r2', tvi.file_revisions['b'])
 
240
        self.assertEqual('unversioned', tvi.file_revisions['c'])
 
241
        os.remove('branch/c')
 
242
 
 
243
        tvi = regen(include_revision_history=True)
 
244
 
 
245
        rev_info = [(rev, message) for rev, message, timestamp, timezone
 
246
                                   in tvi.revisions]
 
247
        self.assertEqual([('r1', 'a'), ('r2', 'b'), ('r3', u'\xe52')], rev_info)
 
248
 
 
249
        # a was modified, so it should show up modified again
 
250
        self.build_tree(['branch/a', 'branch/c'])
 
251
        wt.add('c')
 
252
        wt.rename_one('b', 'd')
 
253
        tvi = regen(check_for_clean=True, include_file_revisions=True)
 
254
        self.assertEqual(['', 'a', 'b', 'c', 'd'],
 
255
                          sorted(tvi.file_revisions.keys()))
 
256
        self.assertEqual('modified', tvi.file_revisions['a'])
 
257
        self.assertEqual('renamed to d', tvi.file_revisions['b'])
 
258
        self.assertEqual('new', tvi.file_revisions['c'])
 
259
        self.assertEqual('renamed from b', tvi.file_revisions['d'])
 
260
 
 
261
        wt.commit('modified', rev_id='r4')
 
262
        wt.remove(['c', 'd'])
 
263
        os.remove('branch/d')
 
264
        tvi = regen(check_for_clean=True, include_file_revisions=True)
 
265
        self.assertEqual(['', 'a', 'c', 'd'],
 
266
                          sorted(tvi.file_revisions.keys()))
 
267
        self.assertEqual('r4', tvi.file_revisions['a'])
 
268
        self.assertEqual('unversioned', tvi.file_revisions['c'])
 
269
        self.assertEqual('removed', tvi.file_revisions['d'])
 
270
 
 
271
    def test_custom_null(self):
 
272
        sio = StringIO()
 
273
        wt = self.make_branch_and_tree('branch')
 
274
        builder = CustomVersionInfoBuilder(wt.branch, working_tree=wt,
 
275
            template='revno: {revno}')
 
276
        builder.generate(sio)
 
277
        self.assertEquals("revno: 0", sio.getvalue())
 
278
 
 
279
        builder = CustomVersionInfoBuilder(wt.branch, working_tree=wt, 
 
280
            template='{revno} revid: {revision_id}')
 
281
        # revision_id is not available yet
 
282
        self.assertRaises(errors.MissingTemplateVariable, 
 
283
            builder.generate, sio)
 
284
 
 
285
    def test_custom_version_text(self):
 
286
        wt = self.create_branch()
 
287
 
 
288
        def regen(tpl, **kwargs):
 
289
            sio = StringIO()
 
290
            builder = CustomVersionInfoBuilder(wt.branch, working_tree=wt,
 
291
                                               template=tpl, **kwargs)
 
292
            builder.generate(sio)
 
293
            val = sio.getvalue()
 
294
            return val
 
295
 
 
296
        val = regen('build-date: "{build_date}"\ndate: "{date}"')
 
297
        self.assertContainsRe(val, 'build-date: "[0-9-+: ]+"')
 
298
        self.assertContainsRe(val, 'date: "[0-9-+: ]+"')
 
299
 
 
300
        val = regen('revno: {revno}')
 
301
        self.assertEqual(val, 'revno: 3')
 
302
 
 
303
        val = regen('revision-id: {revision_id}')
 
304
        self.assertEqual(val, 'revision-id: r3')
 
305
 
 
306
        val = regen('clean: {clean}', check_for_clean=True)
 
307
        self.assertEqual(val, 'clean: 1')
 
308
 
 
309
        self.build_tree(['branch/c'])
 
310
        val = regen('clean: {clean}', check_for_clean=True)
 
311
        self.assertEqual(val, 'clean: 0')
 
312
        os.remove('branch/c')
 
313
 
 
314
    def test_custom_without_template(self):
 
315
        builder = CustomVersionInfoBuilder(None)
 
316
        sio = StringIO()
 
317
        self.assertRaises(errors.NoTemplate, builder.generate, sio)
 
318
 
 
319
 
 
320
class TestBuilder(version_info_formats.VersionInfoBuilder):
 
321
    pass
 
322
 
 
323
 
 
324
class TestVersionInfoFormatRegistry(tests.TestCase):
 
325
 
 
326
    def setUp(self):
 
327
        super(TestVersionInfoFormatRegistry, self).setUp()
 
328
        registry = version_info_formats.format_registry
 
329
        self._default_key = registry._default_key
 
330
        self._dict = registry._dict.copy()
 
331
        self._help_dict = registry._help_dict.copy()
 
332
        self._info_dict = registry._info_dict.copy()
 
333
        self.addCleanup(self._cleanup)
 
334
 
 
335
    def _cleanup(self):
 
336
        # Restore the registry to pristine state after the test runs
 
337
        registry = version_info_formats.format_registry
 
338
        registry._default_key = self._default_key
 
339
        registry._dict = self._dict
 
340
        registry._help_dict = self._help_dict
 
341
        registry._info_dict = self._info_dict
 
342
 
 
343
    def test_register_remove(self):
 
344
        registry = version_info_formats.format_registry
 
345
        registry.register('testbuilder',
 
346
            TestBuilder, 'a simple test builder')
 
347
        self.assertIs(TestBuilder, registry.get('testbuilder'))
 
348
        self.assertEqual('a simple test builder',
 
349
                         registry.get_help('testbuilder'))
 
350
        registry.remove('testbuilder')
 
351
        self.assertRaises(KeyError, registry.get, 'testbuilder')