/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 breezy/tests/test_symbol_versioning.py

  • Committer: Jelmer Vernooij
  • Date: 2020-04-05 19:11:34 UTC
  • mto: (7490.7.16 work)
  • mto: This revision was merged to the branch mainline in revision 7501.
  • Revision ID: jelmer@jelmer.uk-20200405191134-0aebh8ikiwygxma5
Populate the .gitignore file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_symbol_versioning.py
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
18
18
 
19
19
import warnings
20
20
 
21
 
from bzrlib import symbol_versioning
22
 
from bzrlib.symbol_versioning import (
 
21
from breezy import symbol_versioning
 
22
from breezy.sixish import PY3
 
23
from breezy.symbol_versioning import (
23
24
    deprecated_function,
24
25
    deprecated_in,
25
 
    deprecated_list,
26
26
    deprecated_method,
27
27
    )
28
 
from bzrlib.tests import TestCase
 
28
from breezy.tests import TestCase
29
29
 
30
30
 
31
31
@deprecated_function(deprecated_in((0, 7, 0)))
35
35
 
36
36
 
37
37
a_deprecated_list = symbol_versioning.deprecated_list(deprecated_in((0, 9, 0)),
38
 
    'a_deprecated_list', ['one'], extra="Don't use me")
 
38
                                                      'a_deprecated_list', ['one'], extra="Don't use me")
39
39
 
40
40
 
41
41
a_deprecated_dict = symbol_versioning.DeprecatedDict(
54
54
    def setUp(self):
55
55
        super(TestDeprecationWarnings, self).setUp()
56
56
        self._warnings = []
57
 
    
 
57
 
58
58
    @deprecated_method(deprecated_in((0, 7, 0)))
59
59
    def deprecated_method(self):
60
60
        """Deprecated method docstring.
70
70
        return 1
71
71
 
72
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)
 
73
        if PY3:
 
74
            expected_warning = (
 
75
                "breezy.tests.test_symbol_versioning.TestDeprecationWarnings."
 
76
                "deprecated_static "
 
77
                "was deprecated in version 0.7.0.", DeprecationWarning, 2)
 
78
        else:
 
79
            # XXX: The results are not quite right because the class name is not
 
80
            # shown on Python 2- however it is enough to give people a good indication of
 
81
            # where the problem is.
 
82
            expected_warning = (
 
83
                "breezy.tests.test_symbol_versioning."
 
84
                "deprecated_static "
 
85
                "was deprecated in version 0.7.0.", DeprecationWarning, 2)
80
86
        expected_docstring = (
81
87
            'Deprecated static.\n'
82
88
            '\n'
85
91
        self.check_deprecated_callable(
86
92
            expected_warning, expected_docstring,
87
93
            "deprecated_static",
88
 
            "bzrlib.tests.test_symbol_versioning",
 
94
            "breezy.tests.test_symbol_versioning",
89
95
            self.deprecated_static)
90
96
 
91
97
    def test_deprecated_method(self):
92
98
        expected_warning = (
93
 
            "bzrlib.tests.test_symbol_versioning."
 
99
            "breezy.tests.test_symbol_versioning."
94
100
            "TestDeprecationWarnings.deprecated_method "
95
101
            "was deprecated in version 0.7.0.", DeprecationWarning, 2)
96
102
        expected_docstring = (
102
108
            '        ')
103
109
        self.check_deprecated_callable(expected_warning, expected_docstring,
104
110
                                       "deprecated_method",
105
 
                                       "bzrlib.tests.test_symbol_versioning",
 
111
                                       "breezy.tests.test_symbol_versioning",
106
112
                                       self.deprecated_method)
107
113
 
108
114
    def test_deprecated_function(self):
109
115
        expected_warning = (
110
 
            "bzrlib.tests.test_symbol_versioning.sample_deprecated_function "
 
116
            "breezy.tests.test_symbol_versioning.sample_deprecated_function "
111
117
            "was deprecated in version 0.7.0.", DeprecationWarning, 2)
112
118
        expected_docstring = ('Deprecated function docstring.\n'
113
119
                              '\n'
115
121
                              )
116
122
        self.check_deprecated_callable(expected_warning, expected_docstring,
117
123
                                       "sample_deprecated_function",
118
 
                                       "bzrlib.tests.test_symbol_versioning",
 
124
                                       "breezy.tests.test_symbol_versioning",
119
125
                                       sample_deprecated_function)
120
126
 
121
127
    def test_deprecated_list(self):
133
139
            self.assertEqual(['one', 'foo'], a_deprecated_list)
134
140
 
135
141
            a_deprecated_list.extend(['bar', 'baz'])
136
 
            self.assertEqual([expected_warning]*2, self._warnings)
 
142
            self.assertEqual([expected_warning] * 2, self._warnings)
137
143
            self.assertEqual(['one', 'foo', 'bar', 'baz'], a_deprecated_list)
138
144
 
139
145
            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)
 
146
            self.assertEqual([expected_warning] * 3, self._warnings)
 
147
            self.assertEqual(
 
148
                ['one', 'xxx', 'foo', 'bar', 'baz'], a_deprecated_list)
142
149
 
143
150
            a_deprecated_list.remove('foo')
144
 
            self.assertEqual([expected_warning]*4, self._warnings)
 
151
            self.assertEqual([expected_warning] * 4, self._warnings)
145
152
            self.assertEqual(['one', 'xxx', 'bar', 'baz'], a_deprecated_list)
146
153
 
147
154
            val = a_deprecated_list.pop()
148
 
            self.assertEqual([expected_warning]*5, self._warnings)
 
155
            self.assertEqual([expected_warning] * 5, self._warnings)
149
156
            self.assertEqual('baz', val)
150
157
            self.assertEqual(['one', 'xxx', 'bar'], a_deprecated_list)
151
158
 
152
159
            val = a_deprecated_list.pop(1)
153
 
            self.assertEqual([expected_warning]*6, self._warnings)
 
160
            self.assertEqual([expected_warning] * 6, self._warnings)
154
161
            self.assertEqual('xxx', val)
155
162
            self.assertEqual(['one', 'bar'], a_deprecated_list)
156
163
        finally:
175
182
        finally:
176
183
            symbol_versioning.set_warning_method(old_warning_method)
177
184
 
178
 
 
179
185
    def check_deprecated_callable(self, expected_warning, expected_docstring,
180
186
                                  expected_name, expected_module,
181
187
                                  deprecated_callable):
190
196
            deprecated_callable()
191
197
            self.assertEqual([expected_warning, expected_warning],
192
198
                             self._warnings)
193
 
            self.assertEqualDiff(expected_docstring, deprecated_callable.__doc__)
 
199
            self.assertEqualDiff(expected_docstring,
 
200
                                 deprecated_callable.__doc__)
194
201
            self.assertEqualDiff(expected_name, deprecated_callable.__name__)
195
 
            self.assertEqualDiff(expected_module, deprecated_callable.__module__)
 
202
            self.assertEqualDiff(
 
203
                expected_module, deprecated_callable.__module__)
196
204
            self.assertTrue(deprecated_callable.is_deprecated)
197
205
        finally:
198
206
            symbol_versioning.set_warning_method(old_warning_method)
203
211
        self.assertEqual(True, symbol_versioning.deprecated_passed(False))
204
212
        self.assertEqual(False,
205
213
                         symbol_versioning.deprecated_passed(
206
 
                            symbol_versioning.DEPRECATED_PARAMETER))
 
214
                             symbol_versioning.DEPRECATED_PARAMETER))
207
215
 
208
216
    def test_deprecation_string(self):
209
217
        """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(
 
218
        err_message = symbol_versioning.deprecation_string(
214
219
            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))))
 
220
            deprecated_in((0, 11, 0)))
 
221
        self.assertEqual(err_message,
 
222
                         'breezy.tests.test_symbol_versioning.TestDeprecationWarnings.'
 
223
                         'test_deprecation_string was deprecated in '
 
224
                         'version 0.11.0.')
 
225
 
 
226
        self.assertEqual('breezy.symbol_versioning.deprecated_function was '
 
227
                         'deprecated in version 0.11.0.',
 
228
                         symbol_versioning.deprecation_string(
 
229
                             symbol_versioning.deprecated_function,
 
230
                             deprecated_in((0, 11, 0))))
221
231
 
222
232
 
223
233
class TestSuppressAndActivate(TestCase):
224
234
 
225
235
    def setUp(self):
226
 
        TestCase.setUp(self)
 
236
        super(TestSuppressAndActivate, self).setUp()
227
237
        existing_filters = list(warnings.filters)
 
238
 
228
239
        def restore():
229
240
            warnings.filters[:] = existing_filters
230
241
        self.addCleanup(restore)
241
252
        symbol_versioning.suppress_deprecation_warnings()
242
253
        self.assertFirstWarning('ignore', DeprecationWarning)
243
254
 
 
255
    def test_set_restore_filters(self):
 
256
        original_filters = warnings.filters[:]
 
257
        symbol_versioning.suppress_deprecation_warnings()()
 
258
        self.assertEqual(original_filters, warnings.filters)
 
259
 
244
260
    def test_suppress_deprecation_with_warning_filter(self):
245
261
        """don't suppress if we already have a filter"""
246
262
        warnings.filterwarnings('error', category=Warning)