← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_symbol_versioning.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2007-03-28 06:58:22 UTC
  • mfrom: (2379.2.3 hpss-chroot)
  • Revision ID: pqm@pqm.ubuntu.com-20070328065822-999550a858a3ced3
(robertc) Fix chroot urls to not expose the url of the transport they are protecting, allowing regular url operations to work on them. (Robert Collins, Andrew Bennetts)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_symbol_versioning.py
1
 
# Copyright (C) 2006-2011 Canonical Ltd
 
1
# Copyright (C) 2006, 2007 Canonical Ltd
 
2
#   Authors: Robert Collins <robert.collins@canonical.com>
2
3
#
3
4
# This program is free software; you can redistribute it and/or modify
4
5
# it under the terms of the GNU General Public License as published by
12
13
#
13
14
# You should have received a copy of the GNU General Public License
14
15
# 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
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
17
 
17
18
"""Symbol versioning tests."""
18
19
 
19
 
import warnings
20
 
 
21
 
from bzrlib import symbol_versioning
22
 
from bzrlib.symbol_versioning import (
23
 
    deprecated_function,
24
 
    deprecated_in,
25
 
    deprecated_method,
26
 
    )
 
20
import bzrlib.symbol_versioning as symbol_versioning
27
21
from bzrlib.tests import TestCase
28
22
 
29
23
 
30
 
@deprecated_function(deprecated_in((0, 7, 0)))
31
 
def sample_deprecated_function():
 
24
@symbol_versioning.deprecated_function(symbol_versioning.zero_seven)
 
25
def deprecated_function():
32
26
    """Deprecated function docstring."""
33
27
    return 1
34
28
 
35
29
 
36
 
a_deprecated_list = symbol_versioning.deprecated_list(deprecated_in((0, 9, 0)),
 
30
a_deprecated_list = symbol_versioning.deprecated_list(symbol_versioning.zero_nine,
37
31
    'a_deprecated_list', ['one'], extra="Don't use me")
38
32
 
39
33
 
40
34
a_deprecated_dict = symbol_versioning.DeprecatedDict(
41
 
    deprecated_in((0, 14, 0)),
 
35
    symbol_versioning.zero_fourteen,
42
36
    'a_deprecated_dict',
43
37
    dict(a=42),
44
38
    advice='Pull the other one!',
54
48
        super(TestDeprecationWarnings, self).setUp()
55
49
        self._warnings = []
56
50
    
57
 
    @deprecated_method(deprecated_in((0, 7, 0)))
 
51
    @symbol_versioning.deprecated_method(symbol_versioning.zero_seven)
58
52
    def deprecated_method(self):
59
53
        """Deprecated method docstring.
60
 
 
 
54
        
61
55
        This might explain stuff.
62
56
        """
63
57
        return 1
64
58
 
65
 
    @staticmethod
66
 
    @deprecated_function(deprecated_in((0, 7, 0)))
67
 
    def deprecated_static():
68
 
        """Deprecated static."""
69
 
        return 1
70
 
 
71
 
    def test_deprecated_static(self):
72
 
        # XXX: The results are not quite right because the class name is not
73
 
        # shown - however it is enough to give people a good indication of
74
 
        # where the problem is.
75
 
        expected_warning = (
76
 
            "bzrlib.tests.test_symbol_versioning."
77
 
            "deprecated_static "
78
 
            "was deprecated in version 0.7.0.", DeprecationWarning, 2)
79
 
        expected_docstring = (
80
 
            'Deprecated static.\n'
81
 
            '\n'
82
 
            'This function was deprecated in version 0.7.0.\n'
83
 
            )
84
 
        self.check_deprecated_callable(
85
 
            expected_warning, expected_docstring,
86
 
            "deprecated_static",
87
 
            "bzrlib.tests.test_symbol_versioning",
88
 
            self.deprecated_static)
89
 
 
90
59
    def test_deprecated_method(self):
91
60
        expected_warning = (
92
61
            "bzrlib.tests.test_symbol_versioning."
93
62
            "TestDeprecationWarnings.deprecated_method "
94
 
            "was deprecated in version 0.7.0.", DeprecationWarning, 2)
95
 
        expected_docstring = (
96
 
            'Deprecated method docstring.\n'
97
 
            '\n'
98
 
            '        This might explain stuff.\n'
99
 
            '        \n'
100
 
            '        This method was deprecated in version 0.7.0.\n'
101
 
            '        ')
 
63
            "was deprecated in version 0.7.", DeprecationWarning, 2)
 
64
        expected_docstring = ('Deprecated method docstring.\n'
 
65
                              '        \n'
 
66
                              '        This might explain stuff.\n'
 
67
                              '        \n'
 
68
                              '        This method was deprecated in version 0.7.\n'
 
69
                              '        ')
102
70
        self.check_deprecated_callable(expected_warning, expected_docstring,
103
71
                                       "deprecated_method",
104
72
                                       "bzrlib.tests.test_symbol_versioning",
106
74
 
107
75
    def test_deprecated_function(self):
108
76
        expected_warning = (
109
 
            "bzrlib.tests.test_symbol_versioning.sample_deprecated_function "
110
 
            "was deprecated in version 0.7.0.", DeprecationWarning, 2)
 
77
            "bzrlib.tests.test_symbol_versioning.deprecated_function "
 
78
            "was deprecated in version 0.7.", DeprecationWarning, 2)
111
79
        expected_docstring = ('Deprecated function docstring.\n'
112
80
                              '\n'
113
 
                              'This function was deprecated in version 0.7.0.\n'
 
81
                              'This function was deprecated in version 0.7.\n'
114
82
                              )
115
83
        self.check_deprecated_callable(expected_warning, expected_docstring,
116
 
                                       "sample_deprecated_function",
 
84
                                       "deprecated_function",
117
85
                                       "bzrlib.tests.test_symbol_versioning",
118
 
                                       sample_deprecated_function)
 
86
                                       deprecated_function)
119
87
 
120
88
    def test_deprecated_list(self):
121
89
        expected_warning = (
122
 
            "Modifying a_deprecated_list was deprecated in version 0.9.0."
 
90
            "Modifying a_deprecated_list was deprecated in version 0.9."
123
91
            " Don't use me", DeprecationWarning, 3)
124
92
        old_warning_method = symbol_versioning.warn
125
93
        try:
157
125
 
158
126
    def test_deprecated_dict(self):
159
127
        expected_warning = (
160
 
            "access to a_deprecated_dict was deprecated in version 0.14.0."
 
128
            "access to a_deprecated_dict was deprecated in version 0.14."
161
129
            " Pull the other one!", DeprecationWarning, 2)
162
130
        old_warning_method = symbol_versioning.warn
163
131
        try:
178
146
    def check_deprecated_callable(self, expected_warning, expected_docstring,
179
147
                                  expected_name, expected_module,
180
148
                                  deprecated_callable):
181
 
        if __doc__ is None:
182
 
            # With -OO the docstring should just be the deprecated version
183
 
            expected_docstring = expected_docstring.split('\n')[-2].lstrip()
184
149
        old_warning_method = symbol_versioning.warn
185
150
        try:
186
151
            symbol_versioning.set_warning_method(self.capture_warning)
195
160
            self.assertTrue(deprecated_callable.is_deprecated)
196
161
        finally:
197
162
            symbol_versioning.set_warning_method(old_warning_method)
198
 
 
 
163
    
199
164
    def test_deprecated_passed(self):
200
165
        self.assertEqual(True, symbol_versioning.deprecated_passed(None))
201
166
        self.assertEqual(True, symbol_versioning.deprecated_passed(True))
208
173
        """We can get a deprecation string for a method or function."""
209
174
        self.assertEqual('bzrlib.tests.test_symbol_versioning.'
210
175
            'TestDeprecationWarnings.test_deprecation_string was deprecated in '
211
 
            'version 0.11.0.',
 
176
            'version 0.11.',
212
177
            symbol_versioning.deprecation_string(
213
 
            self.test_deprecation_string,
214
 
            deprecated_in((0, 11, 0))))
 
178
            self.test_deprecation_string, symbol_versioning.zero_eleven))
215
179
        self.assertEqual('bzrlib.symbol_versioning.deprecated_function was '
216
 
            'deprecated in version 0.11.0.',
 
180
            'deprecated in version 0.11.',
217
181
            symbol_versioning.deprecation_string(
218
182
                symbol_versioning.deprecated_function,
219
 
                deprecated_in((0, 11, 0))))
220
 
 
221
 
 
222
 
class TestSuppressAndActivate(TestCase):
223
 
 
224
 
    def setUp(self):
225
 
        super(TestSuppressAndActivate, self).setUp()
226
 
        existing_filters = list(warnings.filters)
227
 
        def restore():
228
 
            warnings.filters[:] = existing_filters
229
 
        self.addCleanup(restore)
230
 
        # Clean out the filters so we have a clean slate.
231
 
        warnings.resetwarnings()
232
 
 
233
 
    def assertFirstWarning(self, action, category):
234
 
        """Test the first warning in the filters is correct"""
235
 
        first = warnings.filters[0]
236
 
        self.assertEqual((action, category), (first[0], first[2]))
237
 
 
238
 
    def test_suppress_deprecation_warnings(self):
239
 
        """suppress_deprecation_warnings sets DeprecationWarning to ignored."""
240
 
        symbol_versioning.suppress_deprecation_warnings()
241
 
        self.assertFirstWarning('ignore', DeprecationWarning)
242
 
 
243
 
    def test_set_restore_filters(self):
244
 
        original_filters = warnings.filters[:]
245
 
        symbol_versioning.suppress_deprecation_warnings()()
246
 
        self.assertEqual(original_filters, warnings.filters)
247
 
 
248
 
    def test_suppress_deprecation_with_warning_filter(self):
249
 
        """don't suppress if we already have a filter"""
250
 
        warnings.filterwarnings('error', category=Warning)
251
 
        self.assertFirstWarning('error', Warning)
252
 
        self.assertEqual(1, len(warnings.filters))
253
 
        symbol_versioning.suppress_deprecation_warnings(override=False)
254
 
        self.assertFirstWarning('error', Warning)
255
 
        self.assertEqual(1, len(warnings.filters))
256
 
 
257
 
    def test_suppress_deprecation_with_filter(self):
258
 
        """don't suppress if we already have a filter"""
259
 
        warnings.filterwarnings('error', category=DeprecationWarning)
260
 
        self.assertFirstWarning('error', DeprecationWarning)
261
 
        self.assertEqual(1, len(warnings.filters))
262
 
        symbol_versioning.suppress_deprecation_warnings(override=False)
263
 
        self.assertFirstWarning('error', DeprecationWarning)
264
 
        self.assertEqual(1, len(warnings.filters))
265
 
        symbol_versioning.suppress_deprecation_warnings(override=True)
266
 
        self.assertFirstWarning('ignore', DeprecationWarning)
267
 
        self.assertEqual(2, len(warnings.filters))
268
 
 
269
 
    def test_activate_deprecation_no_error(self):
270
 
        # First nuke the filters, so we know it is clean
271
 
        symbol_versioning.activate_deprecation_warnings()
272
 
        self.assertFirstWarning('default', DeprecationWarning)
273
 
 
274
 
    def test_activate_deprecation_with_error(self):
275
 
        # First nuke the filters, so we know it is clean
276
 
        # Add a warning == error rule
277
 
        warnings.filterwarnings('error', category=Warning)
278
 
        self.assertFirstWarning('error', Warning)
279
 
        self.assertEqual(1, len(warnings.filters))
280
 
        symbol_versioning.activate_deprecation_warnings(override=False)
281
 
        # There should not be a new warning
282
 
        self.assertFirstWarning('error', Warning)
283
 
        self.assertEqual(1, len(warnings.filters))
284
 
 
285
 
    def test_activate_deprecation_with_DW_error(self):
286
 
        # First nuke the filters, so we know it is clean
287
 
        # Add a warning == error rule
288
 
        warnings.filterwarnings('error', category=DeprecationWarning)
289
 
        self.assertFirstWarning('error', DeprecationWarning)
290
 
        self.assertEqual(1, len(warnings.filters))
291
 
        symbol_versioning.activate_deprecation_warnings(override=False)
292
 
        # There should not be a new warning
293
 
        self.assertFirstWarning('error', DeprecationWarning)
294
 
        self.assertEqual(1, len(warnings.filters))
295
 
        symbol_versioning.activate_deprecation_warnings(override=True)
296
 
        self.assertFirstWarning('default', DeprecationWarning)
297
 
        self.assertEqual(2, len(warnings.filters))
 
183
                symbol_versioning.zero_eleven))