/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_symbol_versioning.py

  • Committer: Martin Pool
  • Date: 2007-10-03 08:06:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2901.
  • Revision ID: mbp@sourcefrog.net-20071003080644-oivy0gkg98sex0ed
Avoid internal error tracebacks on failure to lock on readonly transport (#129701).

Add new LockFailed, which doesn't imply that we failed to get it because of
contention.  Raise this if we fail to create the pending or lock directories
because of Transport errors.

UnlockableTransport is not an internal error.

ReadOnlyLockError has a message which didn't match its name or usage; it's now
deprecated and callers are updated to use LockFailed which is more appropriate.

Add zero_ninetytwo deprecation symbol.

Unify assertMatchesRe with TestCase.assertContainsRe.

When the constructor is deprecated, just say that the class is deprecated, not
the __init__ method - this works better with applyDeprecated in tests.

Show diffs side-by-side

added added

removed removed

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