/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: Breezy landing bot
  • Author(s): Jelmer Vernooij
  • Date: 2020-08-23 01:15:41 UTC
  • mfrom: (7520.1.4 merge-3.1)
  • Revision ID: breezy.the.bot@gmail.com-20200823011541-nv0oh7nzaganx2qy
Merge lp:brz/3.1.

Merged from https://code.launchpad.net/~jelmer/brz/merge-3.1/+merge/389690

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.symbol_versioning import (
23
23
    deprecated_function,
24
24
    deprecated_in,
25
 
    deprecated_list,
26
25
    deprecated_method,
27
26
    )
28
 
from bzrlib.tests import TestCase
 
27
from breezy.tests import TestCase
29
28
 
30
29
 
31
30
@deprecated_function(deprecated_in((0, 7, 0)))
35
34
 
36
35
 
37
36
a_deprecated_list = symbol_versioning.deprecated_list(deprecated_in((0, 9, 0)),
38
 
    'a_deprecated_list', ['one'], extra="Don't use me")
 
37
                                                      'a_deprecated_list', ['one'], extra="Don't use me")
39
38
 
40
39
 
41
40
a_deprecated_dict = symbol_versioning.DeprecatedDict(
54
53
    def setUp(self):
55
54
        super(TestDeprecationWarnings, self).setUp()
56
55
        self._warnings = []
57
 
    
 
56
 
58
57
    @deprecated_method(deprecated_in((0, 7, 0)))
59
58
    def deprecated_method(self):
60
59
        """Deprecated method docstring.
70
69
        return 1
71
70
 
72
71
    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
72
        expected_warning = (
77
 
            "bzrlib.tests.test_symbol_versioning."
 
73
            "breezy.tests.test_symbol_versioning.TestDeprecationWarnings."
78
74
            "deprecated_static "
79
75
            "was deprecated in version 0.7.0.", DeprecationWarning, 2)
80
76
        expected_docstring = (
85
81
        self.check_deprecated_callable(
86
82
            expected_warning, expected_docstring,
87
83
            "deprecated_static",
88
 
            "bzrlib.tests.test_symbol_versioning",
 
84
            "breezy.tests.test_symbol_versioning",
89
85
            self.deprecated_static)
90
86
 
91
87
    def test_deprecated_method(self):
92
88
        expected_warning = (
93
 
            "bzrlib.tests.test_symbol_versioning."
 
89
            "breezy.tests.test_symbol_versioning."
94
90
            "TestDeprecationWarnings.deprecated_method "
95
91
            "was deprecated in version 0.7.0.", DeprecationWarning, 2)
96
92
        expected_docstring = (
102
98
            '        ')
103
99
        self.check_deprecated_callable(expected_warning, expected_docstring,
104
100
                                       "deprecated_method",
105
 
                                       "bzrlib.tests.test_symbol_versioning",
 
101
                                       "breezy.tests.test_symbol_versioning",
106
102
                                       self.deprecated_method)
107
103
 
108
104
    def test_deprecated_function(self):
109
105
        expected_warning = (
110
 
            "bzrlib.tests.test_symbol_versioning.sample_deprecated_function "
 
106
            "breezy.tests.test_symbol_versioning.sample_deprecated_function "
111
107
            "was deprecated in version 0.7.0.", DeprecationWarning, 2)
112
108
        expected_docstring = ('Deprecated function docstring.\n'
113
109
                              '\n'
115
111
                              )
116
112
        self.check_deprecated_callable(expected_warning, expected_docstring,
117
113
                                       "sample_deprecated_function",
118
 
                                       "bzrlib.tests.test_symbol_versioning",
 
114
                                       "breezy.tests.test_symbol_versioning",
119
115
                                       sample_deprecated_function)
120
116
 
121
117
    def test_deprecated_list(self):
133
129
            self.assertEqual(['one', 'foo'], a_deprecated_list)
134
130
 
135
131
            a_deprecated_list.extend(['bar', 'baz'])
136
 
            self.assertEqual([expected_warning]*2, self._warnings)
 
132
            self.assertEqual([expected_warning] * 2, self._warnings)
137
133
            self.assertEqual(['one', 'foo', 'bar', 'baz'], a_deprecated_list)
138
134
 
139
135
            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)
 
136
            self.assertEqual([expected_warning] * 3, self._warnings)
 
137
            self.assertEqual(
 
138
                ['one', 'xxx', 'foo', 'bar', 'baz'], a_deprecated_list)
142
139
 
143
140
            a_deprecated_list.remove('foo')
144
 
            self.assertEqual([expected_warning]*4, self._warnings)
 
141
            self.assertEqual([expected_warning] * 4, self._warnings)
145
142
            self.assertEqual(['one', 'xxx', 'bar', 'baz'], a_deprecated_list)
146
143
 
147
144
            val = a_deprecated_list.pop()
148
 
            self.assertEqual([expected_warning]*5, self._warnings)
 
145
            self.assertEqual([expected_warning] * 5, self._warnings)
149
146
            self.assertEqual('baz', val)
150
147
            self.assertEqual(['one', 'xxx', 'bar'], a_deprecated_list)
151
148
 
152
149
            val = a_deprecated_list.pop(1)
153
 
            self.assertEqual([expected_warning]*6, self._warnings)
 
150
            self.assertEqual([expected_warning] * 6, self._warnings)
154
151
            self.assertEqual('xxx', val)
155
152
            self.assertEqual(['one', 'bar'], a_deprecated_list)
156
153
        finally:
175
172
        finally:
176
173
            symbol_versioning.set_warning_method(old_warning_method)
177
174
 
178
 
 
179
175
    def check_deprecated_callable(self, expected_warning, expected_docstring,
180
176
                                  expected_name, expected_module,
181
177
                                  deprecated_callable):
190
186
            deprecated_callable()
191
187
            self.assertEqual([expected_warning, expected_warning],
192
188
                             self._warnings)
193
 
            self.assertEqualDiff(expected_docstring, deprecated_callable.__doc__)
 
189
            self.assertEqualDiff(expected_docstring,
 
190
                                 deprecated_callable.__doc__)
194
191
            self.assertEqualDiff(expected_name, deprecated_callable.__name__)
195
 
            self.assertEqualDiff(expected_module, deprecated_callable.__module__)
 
192
            self.assertEqualDiff(
 
193
                expected_module, deprecated_callable.__module__)
196
194
            self.assertTrue(deprecated_callable.is_deprecated)
197
195
        finally:
198
196
            symbol_versioning.set_warning_method(old_warning_method)
203
201
        self.assertEqual(True, symbol_versioning.deprecated_passed(False))
204
202
        self.assertEqual(False,
205
203
                         symbol_versioning.deprecated_passed(
206
 
                            symbol_versioning.DEPRECATED_PARAMETER))
 
204
                             symbol_versioning.DEPRECATED_PARAMETER))
207
205
 
208
206
    def test_deprecation_string(self):
209
207
        """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(
 
208
        err_message = symbol_versioning.deprecation_string(
214
209
            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))))
 
210
            deprecated_in((0, 11, 0)))
 
211
        self.assertEqual(err_message,
 
212
                         'breezy.tests.test_symbol_versioning.TestDeprecationWarnings.'
 
213
                         'test_deprecation_string was deprecated in '
 
214
                         'version 0.11.0.')
 
215
 
 
216
        self.assertEqual('breezy.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
221
 
222
222
 
223
223
class TestSuppressAndActivate(TestCase):
224
224
 
225
225
    def setUp(self):
226
 
        TestCase.setUp(self)
 
226
        super(TestSuppressAndActivate, self).setUp()
227
227
        existing_filters = list(warnings.filters)
 
228
 
228
229
        def restore():
229
230
            warnings.filters[:] = existing_filters
230
231
        self.addCleanup(restore)
241
242
        symbol_versioning.suppress_deprecation_warnings()
242
243
        self.assertFirstWarning('ignore', DeprecationWarning)
243
244
 
 
245
    def test_set_restore_filters(self):
 
246
        original_filters = warnings.filters[:]
 
247
        symbol_versioning.suppress_deprecation_warnings()()
 
248
        self.assertEqual(original_filters, warnings.filters)
 
249
 
244
250
    def test_suppress_deprecation_with_warning_filter(self):
245
251
        """don't suppress if we already have a filter"""
246
252
        warnings.filterwarnings('error', category=Warning)