← Back to branch summary

~cjwatson/lazr.restful/fix-wadl-etag

« back to all changes in this revision

Viewing changes to src/lazr/restful/tests/test_utils.py

  • Committer: Colin Watson
  • Date: 2020-02-13 00:11:04 UTC
  • Revision ID: cjwatson@canonical.com-20200213001104-voblowr0mi4rk73h
Stop using deprecated unittest methods.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lazr/restful/tests/test_utils.py
41
41
    def test_get_current_browser_request_no_interaction(self):
42
42
        # When there's no interaction setup, get_current_browser_request()
43
43
        # returns None.
44
 
        self.assertEquals(None, queryInteraction())
45
 
        self.assertEquals(None, get_current_browser_request())
 
44
        self.assertEqual(None, queryInteraction())
 
45
        self.assertEqual(None, get_current_browser_request())
46
46
 
47
47
    def test_get_current_browser_request(self):
48
48
        # When there is an interaction, it returns the interaction's request.
49
49
        request = TestRequest()
50
50
        newInteraction(request)
51
 
        self.assertEquals(request, get_current_browser_request())
 
51
        self.assertEqual(request, get_current_browser_request())
52
52
        endInteraction()
53
53
 
54
54
    def test_is_total_size_link_active(self):
110
110
        # rename_version works when the given version exists.
111
111
        self.dict.push("original")
112
112
        self.dict.rename_version("original", "renamed")
113
 
        self.assertEquals(self.dict.dict_names, ["renamed"])
 
113
        self.assertEqual(self.dict.dict_names, ["renamed"])
114
114
 
115
115
    def test_rename_version_fails_given_nonexistent_version(self):
116
116
        # rename_version gives KeyError when the given version does
123
123
        # dict_for_name finds a dict with the given name in the stack.
124
124
        self.dict.push("name1")
125
125
        self.dict['key'] = 'value1'
126
 
        self.assertEquals(
 
126
        self.assertEqual(
127
127
            self.dict.dict_for_name('name1'), dict(key='value1'))
128
128
 
129
129
    def test_dict_for_name_finds_first_dict(self):
134
134
        self.dict.push("name2")
135
135
        self.dict.push("name1")
136
136
        self.dict['key'] = 'value2'
137
 
        self.assertEquals(
 
137
        self.assertEqual(
138
138
            self.dict.dict_for_name('name1'), dict(key='value1'))
139
139
 
140
140
    def test_dict_for_name_returns_None_if_no_such_name(self):
141
141
        # If there's no dict with the given name, dict_for_name
142
142
        # returns None.
143
 
        self.assertEquals(None, self.dict.dict_for_name("name1"))
 
143
        self.assertEqual(None, self.dict.dict_for_name("name1"))
144
144
 
145
145
    def test_dict_for_name_returns_default_if_no_such_name(self):
146
146
        # If there's no dict with the given name, and a default value
147
147
        # is provided, dict_for_name returns the default.
148
148
        obj = object()
149
 
        self.assertEquals(obj, self.dict.dict_for_name("name1", obj))
 
149
        self.assertEqual(obj, self.dict.dict_for_name("name1", obj))
150
150
 
151
151
    def test_normalize_for_versions_fills_in_blanks(self):
152
152
        # `normalize_for_versions` makes sure a VersionedDict has
154
154
        self.dict.push("name2")
155
155
        self.dict['key'] = 'value'
156
156
        self.dict.normalize_for_versions(['name1', 'name2', 'name3'])
157
 
        self.assertEquals(
 
157
        self.assertEqual(
158
158
            self.dict.stack,
159
159
            [('name1', dict()),
160
160
             ('name2', dict(key='value')),
165
165
        self.dict['key'] = 'value'
166
166
        self.dict.normalize_for_versions(
167
167
            ['name1', 'name2'], dict(default=True))
168
 
        self.assertEquals(
 
168
        self.assertEqual(
169
169
            self.dict.stack,
170
170
            [('name1', dict(default=True)),
171
171
             ('name2', dict(key='value'))])
174
174
        self.dict.push("nosuchversion")
175
175
        exception = self.assertRaises(
176
176
            ValueError, self.dict.normalize_for_versions, ['name1'])
177
 
        self.assertEquals(
 
177
        self.assertEqual(
178
178
            str(exception), 'Unrecognized version "nosuchversion".')
179
179
 
180
180
    def test_normalize_for_versions_rejects_duplicate_versions(self):
182
182
        self.dict.push("name1")
183
183
        exception = self.assertRaises(
184
184
            ValueError, self.dict.normalize_for_versions, ['name1', 'name2'])
185
 
        self.assertEquals(
 
185
        self.assertEqual(
186
186
            str(exception), 'Duplicate definitions for version "name1".')
187
187
 
188
188
    def test_normalize_for_versions_rejects_misordered_versions(self):
190
190
        self.dict.push("name1")
191
191
        exception = self.assertRaises(
192
192
            ValueError, self.dict.normalize_for_versions, ['name1', 'name2'])
193
 
        self.assertEquals(
 
193
        self.assertEqual(
194
194
            str(exception),
195
195
            'Version "name1" defined after the later version "name2".')
196
196
 
199
199
        exception = self.assertRaises(
200
200
            ValueError, self.dict.normalize_for_versions, ['name1'],
201
201
            error_prefix='Error test: ')
202
 
        self.assertEquals(
 
202
        self.assertEqual(
203
203
            str(exception),
204
204
            'Error test: Unrecognized version "nosuchversion".')
205
205
 
208
208
class TestParseAcceptStyleHeader(unittest.TestCase):
209
209
 
210
210
    def test_single_value(self):
211
 
        self.assertEquals(parse_accept_style_header("foo"), ["foo"])
 
211
        self.assertEqual(parse_accept_style_header("foo"), ["foo"])
212
212
 
213
213
    def test_multiple_unodered_values(self):
214
 
        self.assertEquals(
 
214
        self.assertEqual(
215
215
            parse_accept_style_header("foo, bar"),
216
216
            ["foo", "bar"])
217
217
 
218
 
        self.assertEquals(
 
218
        self.assertEqual(
219
219
            parse_accept_style_header("foo, bar,baz"),
220
220
            ["foo", "bar", "baz"])
221
221
 
222
222
    def test_highest_quality_parameter_wins(self):
223
 
        self.assertEquals(
 
223
        self.assertEqual(
224
224
            parse_accept_style_header("foo;q=0.001, bar;q=0.05, baz;q=0.1"),
225
225
            ["baz", "bar", "foo"])
226
226
 
227
227
    def test_quality_zero_is_omitted(self):
228
 
        self.assertEquals(
 
228
        self.assertEqual(
229
229
            parse_accept_style_header("foo;q=0, bar;q=0.5"), ["bar"])
230
230
 
231
231
    def test_duplicate_values_are_collapsed(self):
232
 
        self.assertEquals(
 
232
        self.assertEqual(
233
233
            parse_accept_style_header("foo;q=0.1, foo;q=0.5, bar;q=0.3"),
234
234
            ["foo", "bar"])
235
235
 
236
236
    def test_no_quality_parameter_is_implicit_one_point_zero(self):
237
 
        self.assertEquals(
 
237
        self.assertEqual(
238
238
            parse_accept_style_header("foo;q=0.5, bar"),
239
239
            ["bar", "foo"])
240
240
 
241
241
    def test_standalone_parameter_is_untouched(self):
242
 
        self.assertEquals(
 
242
        self.assertEqual(
243
243
            parse_accept_style_header("foo;a=0.5"),
244
244
            ["foo;a=0.5"])
245
245
 
246
246
    def test_quality_parameter_is_removed_next_parameter_is_untouched(self):
247
 
        self.assertEquals(
 
247
        self.assertEqual(
248
248
            parse_accept_style_header("foo;a=bar;q=0.5"),
249
249
            ["foo;a=bar"])
250
250
 
251
251
    def test_quality_parameter_is_removed_earlier_parameter_is_untouched(self):
252
 
        self.assertEquals(
 
252
        self.assertEqual(
253
253
            parse_accept_style_header("foo;q=0.5;a=bar"),
254
254
            ["foo;a=bar"])
255
255
 
256
256
    def test_quality_parameter_is_removed_surrounding_parameters_are_untouched(self):
257
 
        self.assertEquals(
 
257
        self.assertEqual(
258
258
            parse_accept_style_header("foo;a=bar;q=0.5;b=baz"),
259
259
            ["foo;a=bar;b=baz"])