/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: 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_symbol_versioning.py
 
1
# Copyright (C) 2006, 2007, 2009 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
"""Symbol versioning tests."""
 
18
 
 
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
    )
 
28
from bzrlib.tests import TestCase
 
29
 
 
30
 
 
31
@deprecated_function(deprecated_in((0, 7, 0)))
 
32
def sample_deprecated_function():
 
33
    """Deprecated function docstring."""
 
34
    return 1
 
35
 
 
36
 
 
37
a_deprecated_list = symbol_versioning.deprecated_list(deprecated_in((0, 9, 0)),
 
38
    'a_deprecated_list', ['one'], extra="Don't use me")
 
39
 
 
40
 
 
41
a_deprecated_dict = symbol_versioning.DeprecatedDict(
 
42
    deprecated_in((0, 14, 0)),
 
43
    'a_deprecated_dict',
 
44
    dict(a=42),
 
45
    advice='Pull the other one!',
 
46
    )
 
47
 
 
48
 
 
49
class TestDeprecationWarnings(TestCase):
 
50
 
 
51
    def capture_warning(self, message, category, stacklevel=None):
 
52
        self._warnings.append((message, category, stacklevel))
 
53
 
 
54
    def setUp(self):
 
55
        super(TestDeprecationWarnings, self).setUp()
 
56
        self._warnings = []
 
57
    
 
58
    @deprecated_method(deprecated_in((0, 7, 0)))
 
59
    def deprecated_method(self):
 
60
        """Deprecated method docstring.
 
61
 
 
62
        This might explain stuff.
 
63
        """
 
64
        return 1
 
65
 
 
66
    @staticmethod
 
67
    @deprecated_function(deprecated_in((0, 7, 0)))
 
68
    def deprecated_static():
 
69
        """Deprecated static."""
 
70
        return 1
 
71
 
 
72
    def test_deprecated_static(self):
 
73
        # XXX: The results are not quite right because the class name is not
 
74
        # shown - however it is enough to give people a good indication of
 
75
        # where the problem is.
 
76
        expected_warning = (
 
77
            "bzrlib.tests.test_symbol_versioning."
 
78
            "deprecated_static "
 
79
            "was deprecated in version 0.7.0.", DeprecationWarning, 2)
 
80
        expected_docstring = (
 
81
            'Deprecated static.\n'
 
82
            '\n'
 
83
            'This function was deprecated in version 0.7.0.\n'
 
84
            )
 
85
        self.check_deprecated_callable(
 
86
            expected_warning, expected_docstring,
 
87
            "deprecated_static",
 
88
            "bzrlib.tests.test_symbol_versioning",
 
89
            self.deprecated_static)
 
90
 
 
91
    def test_deprecated_method(self):
 
92
        expected_warning = (
 
93
            "bzrlib.tests.test_symbol_versioning."
 
94
            "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
            '        ')
 
103
        self.check_deprecated_callable(expected_warning, expected_docstring,
 
104
                                       "deprecated_method",
 
105
                                       "bzrlib.tests.test_symbol_versioning",
 
106
                                       self.deprecated_method)
 
107
 
 
108
    def test_deprecated_function(self):
 
109
        expected_warning = (
 
110
            "bzrlib.tests.test_symbol_versioning.sample_deprecated_function "
 
111
            "was deprecated in version 0.7.0.", DeprecationWarning, 2)
 
112
        expected_docstring = ('Deprecated function docstring.\n'
 
113
                              '\n'
 
114
                              'This function was deprecated in version 0.7.0.\n'
 
115
                              )
 
116
        self.check_deprecated_callable(expected_warning, expected_docstring,
 
117
                                       "sample_deprecated_function",
 
118
                                       "bzrlib.tests.test_symbol_versioning",
 
119
                                       sample_deprecated_function)
 
120
 
 
121
    def test_deprecated_list(self):
 
122
        expected_warning = (
 
123
            "Modifying a_deprecated_list was deprecated in version 0.9.0."
 
124
            " Don't use me", DeprecationWarning, 3)
 
125
        old_warning_method = symbol_versioning.warn
 
126
        try:
 
127
            symbol_versioning.set_warning_method(self.capture_warning)
 
128
            self.assertEqual(['one'], a_deprecated_list)
 
129
            self.assertEqual([], self._warnings)
 
130
 
 
131
            a_deprecated_list.append('foo')
 
132
            self.assertEqual([expected_warning], self._warnings)
 
133
            self.assertEqual(['one', 'foo'], a_deprecated_list)
 
134
 
 
135
            a_deprecated_list.extend(['bar', 'baz'])
 
136
            self.assertEqual([expected_warning]*2, self._warnings)
 
137
            self.assertEqual(['one', 'foo', 'bar', 'baz'], a_deprecated_list)
 
138
 
 
139
            a_deprecated_list.insert(1, 'xxx')
 
140
            self.assertEqual([expected_warning]*3, self._warnings)
 
141
            self.assertEqual(['one', 'xxx', 'foo', 'bar', 'baz'], a_deprecated_list)
 
142
 
 
143
            a_deprecated_list.remove('foo')
 
144
            self.assertEqual([expected_warning]*4, self._warnings)
 
145
            self.assertEqual(['one', 'xxx', 'bar', 'baz'], a_deprecated_list)
 
146
 
 
147
            val = a_deprecated_list.pop()
 
148
            self.assertEqual([expected_warning]*5, self._warnings)
 
149
            self.assertEqual('baz', val)
 
150
            self.assertEqual(['one', 'xxx', 'bar'], a_deprecated_list)
 
151
 
 
152
            val = a_deprecated_list.pop(1)
 
153
            self.assertEqual([expected_warning]*6, self._warnings)
 
154
            self.assertEqual('xxx', val)
 
155
            self.assertEqual(['one', 'bar'], a_deprecated_list)
 
156
        finally:
 
157
            symbol_versioning.set_warning_method(old_warning_method)
 
158
 
 
159
    def test_deprecated_dict(self):
 
160
        expected_warning = (
 
161
            "access to a_deprecated_dict was deprecated in version 0.14.0."
 
162
            " Pull the other one!", DeprecationWarning, 2)
 
163
        old_warning_method = symbol_versioning.warn
 
164
        try:
 
165
            symbol_versioning.set_warning_method(self.capture_warning)
 
166
            self.assertEqual(len(a_deprecated_dict), 1)
 
167
            self.assertEqual([expected_warning], self._warnings)
 
168
 
 
169
            a_deprecated_dict['b'] = 42
 
170
            self.assertEqual(a_deprecated_dict['b'], 42)
 
171
            self.assertTrue('b' in a_deprecated_dict)
 
172
            del a_deprecated_dict['b']
 
173
            self.assertFalse('b' in a_deprecated_dict)
 
174
            self.assertEqual([expected_warning] * 6, self._warnings)
 
175
        finally:
 
176
            symbol_versioning.set_warning_method(old_warning_method)
 
177
 
 
178
 
 
179
    def check_deprecated_callable(self, expected_warning, expected_docstring,
 
180
                                  expected_name, expected_module,
 
181
                                  deprecated_callable):
 
182
        old_warning_method = symbol_versioning.warn
 
183
        try:
 
184
            symbol_versioning.set_warning_method(self.capture_warning)
 
185
            self.assertEqual(1, deprecated_callable())
 
186
            self.assertEqual([expected_warning], self._warnings)
 
187
            deprecated_callable()
 
188
            self.assertEqual([expected_warning, expected_warning],
 
189
                             self._warnings)
 
190
            self.assertEqualDiff(expected_docstring, deprecated_callable.__doc__)
 
191
            self.assertEqualDiff(expected_name, deprecated_callable.__name__)
 
192
            self.assertEqualDiff(expected_module, deprecated_callable.__module__)
 
193
            self.assertTrue(deprecated_callable.is_deprecated)
 
194
        finally:
 
195
            symbol_versioning.set_warning_method(old_warning_method)
 
196
 
 
197
    def test_deprecated_passed(self):
 
198
        self.assertEqual(True, symbol_versioning.deprecated_passed(None))
 
199
        self.assertEqual(True, symbol_versioning.deprecated_passed(True))
 
200
        self.assertEqual(True, symbol_versioning.deprecated_passed(False))
 
201
        self.assertEqual(False,
 
202
                         symbol_versioning.deprecated_passed(
 
203
                            symbol_versioning.DEPRECATED_PARAMETER))
 
204
 
 
205
    def test_deprecation_string(self):
 
206
        """We can get a deprecation string for a method or function."""
 
207
        self.assertEqual('bzrlib.tests.test_symbol_versioning.'
 
208
            'TestDeprecationWarnings.test_deprecation_string was deprecated in '
 
209
            'version 0.11.0.',
 
210
            symbol_versioning.deprecation_string(
 
211
            self.test_deprecation_string,
 
212
            deprecated_in((0, 11, 0))))
 
213
        self.assertEqual('bzrlib.symbol_versioning.deprecated_function was '
 
214
            'deprecated in version 0.11.0.',
 
215
            symbol_versioning.deprecation_string(
 
216
                symbol_versioning.deprecated_function,
 
217
                deprecated_in((0, 11, 0))))
 
218
 
 
219
 
 
220
class TestSuppressAndActivate(TestCase):
 
221
 
 
222
    def setUp(self):
 
223
        TestCase.setUp(self)
 
224
        existing_filters = list(warnings.filters)
 
225
        def restore():
 
226
            warnings.filters[:] = existing_filters
 
227
        self.addCleanup(restore)
 
228
        # Clean out the filters so we have a clean slate.
 
229
        warnings.resetwarnings()
 
230
 
 
231
    def assertFirstWarning(self, action, category):
 
232
        """Test the first warning in the filters is correct"""
 
233
        first = warnings.filters[0]
 
234
        self.assertEqual((action, category), (first[0], first[2]))
 
235
 
 
236
    def test_suppress_deprecation_warnings(self):
 
237
        """suppress_deprecation_warnings sets DeprecationWarning to ignored."""
 
238
        symbol_versioning.suppress_deprecation_warnings()
 
239
        self.assertFirstWarning('ignore', DeprecationWarning)
 
240
 
 
241
    def test_suppress_deprecation_with_warning_filter(self):
 
242
        """don't suppress if we already have a filter"""
 
243
        warnings.filterwarnings('error', category=Warning)
 
244
        self.assertFirstWarning('error', Warning)
 
245
        self.assertEqual(1, len(warnings.filters))
 
246
        symbol_versioning.suppress_deprecation_warnings(override=False)
 
247
        self.assertFirstWarning('error', Warning)
 
248
        self.assertEqual(1, len(warnings.filters))
 
249
 
 
250
    def test_suppress_deprecation_with_filter(self):
 
251
        """don't suppress if we already have a filter"""
 
252
        warnings.filterwarnings('error', category=DeprecationWarning)
 
253
        self.assertFirstWarning('error', DeprecationWarning)
 
254
        self.assertEqual(1, len(warnings.filters))
 
255
        symbol_versioning.suppress_deprecation_warnings(override=False)
 
256
        self.assertFirstWarning('error', DeprecationWarning)
 
257
        self.assertEqual(1, len(warnings.filters))
 
258
        symbol_versioning.suppress_deprecation_warnings(override=True)
 
259
        self.assertFirstWarning('ignore', DeprecationWarning)
 
260
        self.assertEqual(2, len(warnings.filters))
 
261
 
 
262
    def test_activate_deprecation_no_error(self):
 
263
        # First nuke the filters, so we know it is clean
 
264
        symbol_versioning.activate_deprecation_warnings()
 
265
        self.assertFirstWarning('default', DeprecationWarning)
 
266
 
 
267
    def test_activate_deprecation_with_error(self):
 
268
        # First nuke the filters, so we know it is clean
 
269
        # Add a warning == error rule
 
270
        warnings.filterwarnings('error', category=Warning)
 
271
        self.assertFirstWarning('error', Warning)
 
272
        self.assertEqual(1, len(warnings.filters))
 
273
        symbol_versioning.activate_deprecation_warnings(override=False)
 
274
        # There should not be a new warning
 
275
        self.assertFirstWarning('error', Warning)
 
276
        self.assertEqual(1, len(warnings.filters))
 
277
 
 
278
    def test_activate_deprecation_with_DW_error(self):
 
279
        # First nuke the filters, so we know it is clean
 
280
        # Add a warning == error rule
 
281
        warnings.filterwarnings('error', category=DeprecationWarning)
 
282
        self.assertFirstWarning('error', DeprecationWarning)
 
283
        self.assertEqual(1, len(warnings.filters))
 
284
        symbol_versioning.activate_deprecation_warnings(override=False)
 
285
        # There should not be a new warning
 
286
        self.assertFirstWarning('error', DeprecationWarning)
 
287
        self.assertEqual(1, len(warnings.filters))
 
288
        symbol_versioning.activate_deprecation_warnings(override=True)
 
289
        self.assertFirstWarning('default', DeprecationWarning)
 
290
        self.assertEqual(2, len(warnings.filters))