/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: 2005-08-24 08:59:32 UTC
  • Revision ID: mbp@sourcefrog.net-20050824085932-c61f1f1f1c930e13
- Add a simple UIFactory 

  The idea of this is to let a client of bzrlib set some 
  policy about how output is displayed.

  In this revision all that's done is that progress bars
  are constructed by a policy established by the application
  rather than being randomly constructed in the library 
  or passed down the calls.  This avoids progress bars
  popping up while running the test suite and cleans up
  some code.

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
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
 
        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
 
        old_warning_method = symbol_versioning.warn
186
 
        try:
187
 
            symbol_versioning.set_warning_method(self.capture_warning)
188
 
            self.assertEqual(1, deprecated_callable())
189
 
            self.assertEqual([expected_warning], self._warnings)
190
 
            deprecated_callable()
191
 
            self.assertEqual([expected_warning, expected_warning],
192
 
                             self._warnings)
193
 
            self.assertEqualDiff(expected_docstring, deprecated_callable.__doc__)
194
 
            self.assertEqualDiff(expected_name, deprecated_callable.__name__)
195
 
            self.assertEqualDiff(expected_module, deprecated_callable.__module__)
196
 
            self.assertTrue(deprecated_callable.is_deprecated)
197
 
        finally:
198
 
            symbol_versioning.set_warning_method(old_warning_method)
199
 
 
200
 
    def test_deprecated_passed(self):
201
 
        self.assertEqual(True, symbol_versioning.deprecated_passed(None))
202
 
        self.assertEqual(True, symbol_versioning.deprecated_passed(True))
203
 
        self.assertEqual(True, symbol_versioning.deprecated_passed(False))
204
 
        self.assertEqual(False,
205
 
                         symbol_versioning.deprecated_passed(
206
 
                            symbol_versioning.DEPRECATED_PARAMETER))
207
 
 
208
 
    def test_deprecation_string(self):
209
 
        """We can get a deprecation string for a method or function."""
210
 
        self.assertEqual('bzrlib.tests.test_symbol_versioning.'
211
 
            'TestDeprecationWarnings.test_deprecation_string was deprecated in '
212
 
            'version 0.11.0.',
213
 
            symbol_versioning.deprecation_string(
214
 
            self.test_deprecation_string,
215
 
            deprecated_in((0, 11, 0))))
216
 
        self.assertEqual('bzrlib.symbol_versioning.deprecated_function was '
217
 
            'deprecated in version 0.11.0.',
218
 
            symbol_versioning.deprecation_string(
219
 
                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))